idx
int64 0
7.85k
| idx_lca
int64 0
223
| offset
int64 162
55k
| repo
stringclasses 62
values | commit_hash
stringclasses 113
values | target_file
stringclasses 134
values | line_type_lca
stringclasses 7
values | ground_truth
stringlengths 1
46
| in_completions
bool 1
class | completion_type
stringclasses 6
values | non_dunder_count_intellij
int64 0
529
| non_dunder_count_jedi
int64 0
128
| start_with_
bool 2
classes | first_occurrence
bool 2
classes | intellij_completions
listlengths 1
532
| jedi_completions
listlengths 3
148
| prefix
stringlengths 162
55k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1,824 | 40 | 6,097 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
_op
| true |
statement
| 11 | 10 | true | false |
[
"_left",
"_op",
"alias",
"_type",
"_right",
"__add__",
"__and__",
"__div__",
"__eq__",
"__ge__",
"__getattr__",
"__gt__",
"__init__",
"__le__",
"__lt__",
"__mul__",
"__ne__",
"__neg__",
"__or__",
"__pos__",
"__sub__",
"__truediv__",
"allItems",
"anyItem",
"define",
"imatches",
"matches",
"for",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "allItems",
"type": "function"
},
{
"name": "anyItem",
"type": "function"
},
{
"name": "define",
"type": "function"
},
{
"name": "imatches",
"type": "function"
},
{
"name": "matches",
"type": "function"
},
{
"name": "_left",
"type": "statement"
},
{
"name": "_op",
"type": "statement"
},
{
"name": "_right",
"type": "statement"
},
{
"name": "_type",
"type": "statement"
},
{
"name": "__add__",
"type": "function"
},
{
"name": "__and__",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__div__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__ge__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "function"
},
{
"name": "__lt__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mul__",
"type": "function"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__neg__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__or__",
"type": "function"
},
{
"name": "__pos__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__sub__",
"type": "function"
},
{
"name": "__truediv__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self.
|
1,825 | 40 | 6,137 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
_op
| true |
statement
| 10 | 10 | true | false |
[
"_op",
"_left",
"alias",
"_type",
"_right",
"__add__",
"__and__",
"__div__",
"__eq__",
"__ge__",
"__getattr__",
"__gt__",
"__init__",
"__le__",
"__lt__",
"__mul__",
"__ne__",
"__neg__",
"__or__",
"__pos__",
"__sub__",
"__truediv__",
"allItems",
"anyItem",
"define",
"imatches",
"matches",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "allItems",
"type": "function"
},
{
"name": "anyItem",
"type": "function"
},
{
"name": "define",
"type": "function"
},
{
"name": "imatches",
"type": "function"
},
{
"name": "matches",
"type": "function"
},
{
"name": "_left",
"type": "statement"
},
{
"name": "_op",
"type": "statement"
},
{
"name": "_right",
"type": "statement"
},
{
"name": "_type",
"type": "statement"
},
{
"name": "__add__",
"type": "function"
},
{
"name": "__and__",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__div__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__ge__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "function"
},
{
"name": "__lt__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mul__",
"type": "function"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__neg__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__or__",
"type": "function"
},
{
"name": "__pos__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__sub__",
"type": "function"
},
{
"name": "__truediv__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self.
|
1,826 | 40 | 6,159 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
_op
| true |
statement
| 10 | 10 | true | false |
[
"_op",
"_left",
"alias",
"_right",
"_type",
"__add__",
"__and__",
"__div__",
"__eq__",
"__ge__",
"__getattr__",
"__gt__",
"__init__",
"__le__",
"__lt__",
"__mul__",
"__ne__",
"__neg__",
"__or__",
"__pos__",
"__sub__",
"__truediv__",
"allItems",
"anyItem",
"define",
"imatches",
"matches",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "allItems",
"type": "function"
},
{
"name": "anyItem",
"type": "function"
},
{
"name": "define",
"type": "function"
},
{
"name": "imatches",
"type": "function"
},
{
"name": "matches",
"type": "function"
},
{
"name": "_left",
"type": "statement"
},
{
"name": "_op",
"type": "statement"
},
{
"name": "_right",
"type": "statement"
},
{
"name": "_type",
"type": "statement"
},
{
"name": "__add__",
"type": "function"
},
{
"name": "__and__",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__div__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__ge__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "function"
},
{
"name": "__lt__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mul__",
"type": "function"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__neg__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__or__",
"type": "function"
},
{
"name": "__pos__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__sub__",
"type": "function"
},
{
"name": "__truediv__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self.
|
1,827 | 40 | 6,208 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
_op
| true |
statement
| 11 | 10 | true | false |
[
"_left",
"_op",
"alias",
"_type",
"_right",
"__add__",
"__and__",
"__div__",
"__eq__",
"__ge__",
"__getattr__",
"__gt__",
"__init__",
"__le__",
"__lt__",
"__mul__",
"__ne__",
"__neg__",
"__or__",
"__pos__",
"__sub__",
"__truediv__",
"allItems",
"anyItem",
"define",
"imatches",
"matches",
"for",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "allItems",
"type": "function"
},
{
"name": "anyItem",
"type": "function"
},
{
"name": "define",
"type": "function"
},
{
"name": "imatches",
"type": "function"
},
{
"name": "matches",
"type": "function"
},
{
"name": "_left",
"type": "statement"
},
{
"name": "_op",
"type": "statement"
},
{
"name": "_right",
"type": "statement"
},
{
"name": "_type",
"type": "statement"
},
{
"name": "__add__",
"type": "function"
},
{
"name": "__and__",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__div__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__ge__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "function"
},
{
"name": "__lt__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mul__",
"type": "function"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__neg__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__or__",
"type": "function"
},
{
"name": "__pos__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__sub__",
"type": "function"
},
{
"name": "__truediv__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self.
|
1,828 | 40 | 6,219 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
_left
| true |
statement
| 11 | 10 | true | false |
[
"_op",
"_left",
"alias",
"_type",
"_right",
"__add__",
"__and__",
"__div__",
"__eq__",
"__ge__",
"__getattr__",
"__gt__",
"__init__",
"__le__",
"__lt__",
"__mul__",
"__ne__",
"__neg__",
"__or__",
"__pos__",
"__sub__",
"__truediv__",
"allItems",
"anyItem",
"define",
"imatches",
"matches",
"for",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "allItems",
"type": "function"
},
{
"name": "anyItem",
"type": "function"
},
{
"name": "define",
"type": "function"
},
{
"name": "imatches",
"type": "function"
},
{
"name": "matches",
"type": "function"
},
{
"name": "_left",
"type": "statement"
},
{
"name": "_op",
"type": "statement"
},
{
"name": "_right",
"type": "statement"
},
{
"name": "_type",
"type": "statement"
},
{
"name": "__add__",
"type": "function"
},
{
"name": "__and__",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__div__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__ge__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "function"
},
{
"name": "__lt__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mul__",
"type": "function"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__neg__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__or__",
"type": "function"
},
{
"name": "__pos__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__sub__",
"type": "function"
},
{
"name": "__truediv__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self.
|
1,829 | 40 | 6,248 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
_op
| true |
statement
| 10 | 10 | true | false |
[
"_op",
"_left",
"alias",
"_right",
"_type",
"__add__",
"__and__",
"__div__",
"__eq__",
"__ge__",
"__getattr__",
"__gt__",
"__init__",
"__le__",
"__lt__",
"__mul__",
"__ne__",
"__neg__",
"__or__",
"__pos__",
"__sub__",
"__truediv__",
"allItems",
"anyItem",
"define",
"imatches",
"matches",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "allItems",
"type": "function"
},
{
"name": "anyItem",
"type": "function"
},
{
"name": "define",
"type": "function"
},
{
"name": "imatches",
"type": "function"
},
{
"name": "matches",
"type": "function"
},
{
"name": "_left",
"type": "statement"
},
{
"name": "_op",
"type": "statement"
},
{
"name": "_right",
"type": "statement"
},
{
"name": "_type",
"type": "statement"
},
{
"name": "__add__",
"type": "function"
},
{
"name": "__and__",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__div__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__ge__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "function"
},
{
"name": "__lt__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mul__",
"type": "function"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__neg__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__or__",
"type": "function"
},
{
"name": "__pos__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__sub__",
"type": "function"
},
{
"name": "__truediv__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self.
|
1,830 | 40 | 6,297 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
_left
| true |
statement
| 11 | 10 | true | false |
[
"_op",
"_left",
"alias",
"_type",
"_right",
"__add__",
"__and__",
"__div__",
"__eq__",
"__ge__",
"__getattr__",
"__gt__",
"__init__",
"__le__",
"__lt__",
"__mul__",
"__ne__",
"__neg__",
"__or__",
"__pos__",
"__sub__",
"__truediv__",
"allItems",
"anyItem",
"define",
"imatches",
"matches",
"for",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "allItems",
"type": "function"
},
{
"name": "anyItem",
"type": "function"
},
{
"name": "define",
"type": "function"
},
{
"name": "imatches",
"type": "function"
},
{
"name": "matches",
"type": "function"
},
{
"name": "_left",
"type": "statement"
},
{
"name": "_op",
"type": "statement"
},
{
"name": "_right",
"type": "statement"
},
{
"name": "_type",
"type": "statement"
},
{
"name": "__add__",
"type": "function"
},
{
"name": "__and__",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__div__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__ge__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "function"
},
{
"name": "__lt__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mul__",
"type": "function"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__neg__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__or__",
"type": "function"
},
{
"name": "__pos__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__sub__",
"type": "function"
},
{
"name": "__truediv__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self.
|
1,831 | 40 | 6,344 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
_op
| true |
statement
| 10 | 10 | true | false |
[
"_op",
"_left",
"alias",
"_right",
"_type",
"__add__",
"__and__",
"__div__",
"__eq__",
"__ge__",
"__getattr__",
"__gt__",
"__init__",
"__le__",
"__lt__",
"__mul__",
"__ne__",
"__neg__",
"__or__",
"__pos__",
"__sub__",
"__truediv__",
"allItems",
"anyItem",
"define",
"imatches",
"matches",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "allItems",
"type": "function"
},
{
"name": "anyItem",
"type": "function"
},
{
"name": "define",
"type": "function"
},
{
"name": "imatches",
"type": "function"
},
{
"name": "matches",
"type": "function"
},
{
"name": "_left",
"type": "statement"
},
{
"name": "_op",
"type": "statement"
},
{
"name": "_right",
"type": "statement"
},
{
"name": "_type",
"type": "statement"
},
{
"name": "__add__",
"type": "function"
},
{
"name": "__and__",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__div__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__ge__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "function"
},
{
"name": "__lt__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mul__",
"type": "function"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__neg__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__or__",
"type": "function"
},
{
"name": "__pos__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__sub__",
"type": "function"
},
{
"name": "__truediv__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self.
|
1,832 | 40 | 6,369 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
_type
| true |
statement
| 10 | 10 | true | false |
[
"_left",
"_type",
"_right",
"alias",
"_op",
"__add__",
"__and__",
"__div__",
"__eq__",
"__ge__",
"__getattr__",
"__gt__",
"__init__",
"__le__",
"__lt__",
"__mul__",
"__ne__",
"__neg__",
"__or__",
"__pos__",
"__sub__",
"__truediv__",
"allItems",
"anyItem",
"define",
"imatches",
"matches",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "allItems",
"type": "function"
},
{
"name": "anyItem",
"type": "function"
},
{
"name": "define",
"type": "function"
},
{
"name": "imatches",
"type": "function"
},
{
"name": "matches",
"type": "function"
},
{
"name": "_left",
"type": "statement"
},
{
"name": "_op",
"type": "statement"
},
{
"name": "_right",
"type": "statement"
},
{
"name": "_type",
"type": "statement"
},
{
"name": "__add__",
"type": "function"
},
{
"name": "__and__",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__div__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__ge__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "function"
},
{
"name": "__lt__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mul__",
"type": "function"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__neg__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__or__",
"type": "function"
},
{
"name": "__pos__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__sub__",
"type": "function"
},
{
"name": "__truediv__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self.
|
1,833 | 40 | 6,493 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
inproject
|
_type
| true |
statement
| 10 | 10 | true | false |
[
"_left",
"alias",
"_right",
"_op",
"_type",
"__add__",
"__and__",
"__div__",
"__eq__",
"__ge__",
"__getattr__",
"__gt__",
"__init__",
"__le__",
"__lt__",
"__mul__",
"__ne__",
"__neg__",
"__or__",
"__pos__",
"__sub__",
"__truediv__",
"allItems",
"anyItem",
"define",
"imatches",
"matches",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "allItems",
"type": "function"
},
{
"name": "anyItem",
"type": "function"
},
{
"name": "define",
"type": "function"
},
{
"name": "imatches",
"type": "function"
},
{
"name": "matches",
"type": "function"
},
{
"name": "_left",
"type": "statement"
},
{
"name": "_op",
"type": "statement"
},
{
"name": "_right",
"type": "statement"
},
{
"name": "_type",
"type": "statement"
},
{
"name": "__add__",
"type": "function"
},
{
"name": "__and__",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__div__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__ge__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "function"
},
{
"name": "__lt__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mul__",
"type": "function"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__neg__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__or__",
"type": "function"
},
{
"name": "__pos__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__sub__",
"type": "function"
},
{
"name": "__truediv__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self.
|
1,834 | 40 | 6,505 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
inproject
|
_left
| true |
statement
| 10 | 10 | true | false |
[
"_left",
"alias",
"_type",
"_op",
"_right",
"__add__",
"__and__",
"__div__",
"__eq__",
"__ge__",
"__getattr__",
"__gt__",
"__init__",
"__le__",
"__lt__",
"__mul__",
"__ne__",
"__neg__",
"__or__",
"__pos__",
"__sub__",
"__truediv__",
"allItems",
"anyItem",
"define",
"imatches",
"matches",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "allItems",
"type": "function"
},
{
"name": "anyItem",
"type": "function"
},
{
"name": "define",
"type": "function"
},
{
"name": "imatches",
"type": "function"
},
{
"name": "matches",
"type": "function"
},
{
"name": "_left",
"type": "statement"
},
{
"name": "_op",
"type": "statement"
},
{
"name": "_right",
"type": "statement"
},
{
"name": "_type",
"type": "statement"
},
{
"name": "__add__",
"type": "function"
},
{
"name": "__and__",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__div__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__ge__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "function"
},
{
"name": "__lt__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mul__",
"type": "function"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__neg__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__or__",
"type": "function"
},
{
"name": "__pos__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__sub__",
"type": "function"
},
{
"name": "__truediv__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self.
|
1,835 | 40 | 6,547 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
_type
| true |
statement
| 11 | 10 | true | false |
[
"_left",
"_op",
"alias",
"_type",
"_right",
"__add__",
"__and__",
"__div__",
"__eq__",
"__ge__",
"__getattr__",
"__gt__",
"__init__",
"__le__",
"__lt__",
"__mul__",
"__ne__",
"__neg__",
"__or__",
"__pos__",
"__sub__",
"__truediv__",
"allItems",
"anyItem",
"define",
"imatches",
"matches",
"for",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "allItems",
"type": "function"
},
{
"name": "anyItem",
"type": "function"
},
{
"name": "define",
"type": "function"
},
{
"name": "imatches",
"type": "function"
},
{
"name": "matches",
"type": "function"
},
{
"name": "_left",
"type": "statement"
},
{
"name": "_op",
"type": "statement"
},
{
"name": "_right",
"type": "statement"
},
{
"name": "_type",
"type": "statement"
},
{
"name": "__add__",
"type": "function"
},
{
"name": "__and__",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__div__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__ge__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "function"
},
{
"name": "__lt__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mul__",
"type": "function"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__neg__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__or__",
"type": "function"
},
{
"name": "__pos__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__sub__",
"type": "function"
},
{
"name": "__truediv__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self.
|
1,836 | 40 | 6,559 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
_left
| true |
statement
| 11 | 10 | true | false |
[
"_left",
"_type",
"alias",
"_op",
"_right",
"__add__",
"__and__",
"__div__",
"__eq__",
"__ge__",
"__getattr__",
"__gt__",
"__init__",
"__le__",
"__lt__",
"__mul__",
"__ne__",
"__neg__",
"__or__",
"__pos__",
"__sub__",
"__truediv__",
"allItems",
"anyItem",
"define",
"imatches",
"matches",
"for",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "allItems",
"type": "function"
},
{
"name": "anyItem",
"type": "function"
},
{
"name": "define",
"type": "function"
},
{
"name": "imatches",
"type": "function"
},
{
"name": "matches",
"type": "function"
},
{
"name": "_left",
"type": "statement"
},
{
"name": "_op",
"type": "statement"
},
{
"name": "_right",
"type": "statement"
},
{
"name": "_type",
"type": "statement"
},
{
"name": "__add__",
"type": "function"
},
{
"name": "__and__",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__div__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__ge__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "function"
},
{
"name": "__lt__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mul__",
"type": "function"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__neg__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__or__",
"type": "function"
},
{
"name": "__pos__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__sub__",
"type": "function"
},
{
"name": "__truediv__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self.
|
1,837 | 40 | 6,615 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
_op
| true |
statement
| 11 | 10 | true | false |
[
"_left",
"_op",
"alias",
"_type",
"_right",
"__add__",
"__and__",
"__div__",
"__eq__",
"__ge__",
"__getattr__",
"__gt__",
"__init__",
"__le__",
"__lt__",
"__mul__",
"__ne__",
"__neg__",
"__or__",
"__pos__",
"__sub__",
"__truediv__",
"allItems",
"anyItem",
"define",
"imatches",
"matches",
"for",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "allItems",
"type": "function"
},
{
"name": "anyItem",
"type": "function"
},
{
"name": "define",
"type": "function"
},
{
"name": "imatches",
"type": "function"
},
{
"name": "matches",
"type": "function"
},
{
"name": "_left",
"type": "statement"
},
{
"name": "_op",
"type": "statement"
},
{
"name": "_right",
"type": "statement"
},
{
"name": "_type",
"type": "statement"
},
{
"name": "__add__",
"type": "function"
},
{
"name": "__and__",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__div__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__ge__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "function"
},
{
"name": "__lt__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mul__",
"type": "function"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__neg__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__or__",
"type": "function"
},
{
"name": "__pos__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__sub__",
"type": "function"
},
{
"name": "__truediv__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self.
|
1,838 | 40 | 6,626 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
_left
| true |
statement
| 11 | 10 | true | false |
[
"_op",
"_left",
"alias",
"_type",
"_right",
"__add__",
"__and__",
"__div__",
"__eq__",
"__ge__",
"__getattr__",
"__gt__",
"__init__",
"__le__",
"__lt__",
"__mul__",
"__ne__",
"__neg__",
"__or__",
"__pos__",
"__sub__",
"__truediv__",
"allItems",
"anyItem",
"define",
"imatches",
"matches",
"for",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "allItems",
"type": "function"
},
{
"name": "anyItem",
"type": "function"
},
{
"name": "define",
"type": "function"
},
{
"name": "imatches",
"type": "function"
},
{
"name": "matches",
"type": "function"
},
{
"name": "_left",
"type": "statement"
},
{
"name": "_op",
"type": "statement"
},
{
"name": "_right",
"type": "statement"
},
{
"name": "_type",
"type": "statement"
},
{
"name": "__add__",
"type": "function"
},
{
"name": "__and__",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__div__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__ge__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "function"
},
{
"name": "__lt__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mul__",
"type": "function"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__neg__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__or__",
"type": "function"
},
{
"name": "__pos__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__sub__",
"type": "function"
},
{
"name": "__truediv__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self.
|
1,839 | 40 | 6,677 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
_type
| true |
statement
| 10 | 10 | true | false |
[
"_left",
"_type",
"_right",
"alias",
"_op",
"__add__",
"__and__",
"__div__",
"__eq__",
"__ge__",
"__getattr__",
"__gt__",
"__init__",
"__le__",
"__lt__",
"__mul__",
"__ne__",
"__neg__",
"__or__",
"__pos__",
"__sub__",
"__truediv__",
"allItems",
"anyItem",
"define",
"imatches",
"matches",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "allItems",
"type": "function"
},
{
"name": "anyItem",
"type": "function"
},
{
"name": "define",
"type": "function"
},
{
"name": "imatches",
"type": "function"
},
{
"name": "matches",
"type": "function"
},
{
"name": "_left",
"type": "statement"
},
{
"name": "_op",
"type": "statement"
},
{
"name": "_right",
"type": "statement"
},
{
"name": "_type",
"type": "statement"
},
{
"name": "__add__",
"type": "function"
},
{
"name": "__and__",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__div__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__ge__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "function"
},
{
"name": "__lt__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mul__",
"type": "function"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__neg__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__or__",
"type": "function"
},
{
"name": "__pos__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__sub__",
"type": "function"
},
{
"name": "__truediv__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self.
|
1,860 | 40 | 8,654 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
multi
| true |
statement
| 10 | 10 | false | true |
[
"func",
"alias",
"expression",
"cap",
"pri",
"__call__",
"__enter__",
"__exit__",
"__init__",
"count",
"define",
"dist",
"multi",
"operator",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.
|
1,861 | 40 | 8,699 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
expression
| true |
statement
| 10 | 10 | false | true |
[
"expression",
"define",
"func",
"alias",
"cap",
"__call__",
"__enter__",
"__exit__",
"__init__",
"count",
"dist",
"multi",
"operator",
"pri",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.
|
1,862 | 40 | 8,834 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
expression
| true |
statement
| 10 | 10 | false | false |
[
"expression",
"func",
"alias",
"count",
"cap",
"__call__",
"__enter__",
"__exit__",
"__init__",
"define",
"dist",
"multi",
"operator",
"pri",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.
|
1,863 | 40 | 9,039 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
expression
| true |
statement
| 10 | 10 | false | false |
[
"func",
"alias",
"expression",
"cap",
"pri",
"__call__",
"__enter__",
"__exit__",
"__init__",
"count",
"define",
"dist",
"multi",
"operator",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.
|
1,864 | 40 | 10,135 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
func
| true |
statement
| 10 | 10 | false | true |
[
"func",
"expression",
"alias",
"dist",
"cap",
"__call__",
"__enter__",
"__exit__",
"__init__",
"count",
"define",
"multi",
"operator",
"pri",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.
|
1,865 | 40 | 10,166 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
func
| true |
statement
| 10 | 10 | false | false |
[
"func",
"alias",
"expression",
"cap",
"pri",
"__call__",
"__enter__",
"__exit__",
"__init__",
"count",
"define",
"dist",
"multi",
"operator",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.
|
1,866 | 40 | 10,198 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
func
| true |
statement
| 10 | 10 | false | false |
[
"func",
"alias",
"expression",
"cap",
"pri",
"__call__",
"__enter__",
"__exit__",
"__init__",
"count",
"define",
"dist",
"multi",
"operator",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.
|
1,867 | 40 | 10,261 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
random
|
operator
| true |
statement
| 11 | 10 | false | true |
[
"expression",
"define",
"func",
"alias",
"operator",
"__call__",
"__enter__",
"__exit__",
"__init__",
"cap",
"count",
"dist",
"multi",
"pri",
"for",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.
|
1,868 | 40 | 10,303 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
random
|
func
| true |
statement
| 11 | 10 | false | false |
[
"expression",
"func",
"operator",
"alias",
"cap",
"__call__",
"__enter__",
"__exit__",
"__init__",
"count",
"define",
"dist",
"multi",
"pri",
"for",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.
|
1,869 | 40 | 10,332 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
operator
| true |
statement
| 10 | 10 | false | false |
[
"alias",
"func",
"expression",
"cap",
"pri",
"__call__",
"__enter__",
"__exit__",
"__init__",
"count",
"define",
"dist",
"multi",
"operator",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.
|
1,870 | 40 | 10,385 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
operator
| true |
statement
| 11 | 10 | false | false |
[
"expression",
"define",
"func",
"alias",
"operator",
"__call__",
"__enter__",
"__exit__",
"__init__",
"cap",
"count",
"dist",
"multi",
"pri",
"for",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.
|
1,871 | 40 | 10,432 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
infile
|
count
| true |
statement
| 10 | 10 | false | true |
[
"func",
"dist",
"cap",
"pri",
"alias",
"__call__",
"__enter__",
"__exit__",
"__init__",
"count",
"define",
"expression",
"multi",
"operator",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.
|
1,872 | 40 | 10,486 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
infile
|
count
| true |
statement
| 10 | 10 | false | false |
[
"expression",
"count",
"func",
"alias",
"define",
"__call__",
"__enter__",
"__exit__",
"__init__",
"cap",
"dist",
"multi",
"operator",
"pri",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.
|
1,873 | 40 | 10,509 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
infile
|
pri
| true |
statement
| 10 | 10 | false | true |
[
"func",
"dist",
"count",
"cap",
"alias",
"__call__",
"__enter__",
"__exit__",
"__init__",
"define",
"expression",
"multi",
"operator",
"pri",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.
|
1,874 | 40 | 10,559 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
pri
| true |
statement
| 10 | 10 | false | false |
[
"expression",
"pri",
"func",
"alias",
"define",
"__call__",
"__enter__",
"__exit__",
"__init__",
"cap",
"count",
"dist",
"multi",
"operator",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.
|
1,875 | 40 | 10,580 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
infile
|
cap
| true |
statement
| 10 | 10 | false | true |
[
"func",
"pri",
"dist",
"count",
"alias",
"__call__",
"__enter__",
"__exit__",
"__init__",
"cap",
"define",
"expression",
"multi",
"operator",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.
|
1,876 | 40 | 10,630 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
cap
| true |
statement
| 10 | 10 | false | false |
[
"expression",
"cap",
"func",
"alias",
"define",
"__call__",
"__enter__",
"__exit__",
"__init__",
"count",
"dist",
"multi",
"operator",
"pri",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.
|
1,877 | 40 | 10,651 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
dist
| true |
statement
| 10 | 10 | false | true |
[
"func",
"cap",
"pri",
"count",
"alias",
"__call__",
"__enter__",
"__exit__",
"__init__",
"define",
"dist",
"expression",
"multi",
"operator",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.
|
1,878 | 40 | 10,725 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
dist
| true |
statement
| 10 | 10 | false | false |
[
"func",
"cap",
"pri",
"count",
"alias",
"__call__",
"__enter__",
"__exit__",
"__init__",
"define",
"dist",
"expression",
"multi",
"operator",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.
|
1,879 | 40 | 10,903 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
commited
|
__init__
| true |
function
| 10 | 10 | true | true |
[
"func",
"cap",
"pri",
"alias",
"__init__",
"__call__",
"__enter__",
"__exit__",
"count",
"define",
"dist",
"expression",
"multi",
"operator",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).
|
1,880 | 40 | 11,018 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
commited
|
__init__
| true |
function
| 10 | 10 | true | false |
[
"func",
"cap",
"pri",
"alias",
"__init__",
"__call__",
"__enter__",
"__exit__",
"count",
"define",
"dist",
"expression",
"multi",
"operator",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).
|
1,881 | 40 | 11,159 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
commited
|
__init__
| true |
function
| 10 | 10 | true | false |
[
"func",
"cap",
"pri",
"alias",
"count",
"__call__",
"__enter__",
"__exit__",
"__init__",
"define",
"dist",
"expression",
"multi",
"operator",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).
|
1,882 | 40 | 11,329 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
commited
|
__init__
| true |
function
| 10 | 10 | true | false |
[
"func",
"cap",
"pri",
"alias",
"count",
"__call__",
"__enter__",
"__exit__",
"__init__",
"define",
"dist",
"expression",
"multi",
"operator",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).
|
1,883 | 40 | 11,501 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
commited
|
__init__
| true |
function
| 10 | 10 | true | false |
[
"func",
"cap",
"pri",
"alias",
"count",
"__call__",
"__enter__",
"__exit__",
"__init__",
"define",
"dist",
"expression",
"multi",
"operator",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "alias",
"type": "statement"
},
{
"name": "cap",
"type": "statement"
},
{
"name": "count",
"type": "statement"
},
{
"name": "define",
"type": "function"
},
{
"name": "dist",
"type": "statement"
},
{
"name": "expression",
"type": "statement"
},
{
"name": "func",
"type": "statement"
},
{
"name": "multi",
"type": "statement"
},
{
"name": "operator",
"type": "statement"
},
{
"name": "pri",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).
|
1,888 | 40 | 12,014 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
func
| true |
statement
| 1 | 1 | false | false |
[
"func",
"__init__",
"__call__",
"__eq__",
"__ne__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "func",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.
|
1,892 | 40 | 12,599 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
infile
|
rules
| true |
statement
| 3 | 3 | false | true |
[
"rules",
"name",
"define",
"__init__",
"__exit__",
"__enter__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "rules",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.
|
1,893 | 40 | 12,727 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
name
| true |
statement
| 4 | 3 | false | true |
[
"rules",
"name",
"define",
"for",
"__init__",
"__enter__",
"__exit__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "rules",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.
|
1,900 | 40 | 13,376 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
infile
|
rule
| true |
statement
| 6 | 6 | false | true |
[
"state_name",
"func",
"rule",
"define",
"when_any",
"__call__",
"__init__",
"when_all",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "func",
"type": "statement"
},
{
"name": "rule",
"type": "statement"
},
{
"name": "state_name",
"type": "statement"
},
{
"name": "when_all",
"type": "function"
},
{
"name": "when_any",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.
|
1,902 | 40 | 13,478 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
rule
| true |
statement
| 6 | 6 | false | false |
[
"state_name",
"func",
"rule",
"define",
"when_all",
"__call__",
"__init__",
"when_any",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "func",
"type": "statement"
},
{
"name": "rule",
"type": "statement"
},
{
"name": "state_name",
"type": "statement"
},
{
"name": "when_all",
"type": "function"
},
{
"name": "when_any",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.
|
1,905 | 40 | 13,764 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
infile
|
rule
| true |
statement
| 6 | 6 | false | false |
[
"func",
"rule",
"state_name",
"define",
"when_all",
"__call__",
"__init__",
"when_any",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "func",
"type": "statement"
},
{
"name": "rule",
"type": "statement"
},
{
"name": "state_name",
"type": "statement"
},
{
"name": "when_all",
"type": "function"
},
{
"name": "when_any",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.
|
1,906 | 40 | 13,794 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
state_name
| true |
statement
| 7 | 6 | false | true |
[
"state_name",
"rule",
"func",
"define",
"when_all",
"__call__",
"__init__",
"when_any",
"for",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "func",
"type": "statement"
},
{
"name": "rule",
"type": "statement"
},
{
"name": "state_name",
"type": "statement"
},
{
"name": "when_all",
"type": "function"
},
{
"name": "when_any",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.
|
1,907 | 40 | 13,811 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
rule
| true |
statement
| 7 | 6 | false | false |
[
"state_name",
"func",
"rule",
"define",
"when_all",
"__call__",
"__init__",
"when_any",
"for",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "func",
"type": "statement"
},
{
"name": "rule",
"type": "statement"
},
{
"name": "state_name",
"type": "statement"
},
{
"name": "when_all",
"type": "function"
},
{
"name": "when_any",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.
|
1,909 | 40 | 13,859 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
func
| true |
statement
| 6 | 6 | false | false |
[
"rule",
"func",
"state_name",
"define",
"when_all",
"__call__",
"__init__",
"when_any",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "func",
"type": "statement"
},
{
"name": "rule",
"type": "statement"
},
{
"name": "state_name",
"type": "statement"
},
{
"name": "when_all",
"type": "function"
},
{
"name": "when_any",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.
|
1,910 | 40 | 13,893 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
state_name
| true |
statement
| 7 | 6 | false | false |
[
"rule",
"state_name",
"func",
"define",
"when_all",
"__call__",
"__init__",
"when_any",
"for",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "func",
"type": "statement"
},
{
"name": "rule",
"type": "statement"
},
{
"name": "state_name",
"type": "statement"
},
{
"name": "when_all",
"type": "function"
},
{
"name": "when_any",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.
|
1,911 | 40 | 13,918 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
func
| true |
statement
| 7 | 6 | false | false |
[
"func",
"state_name",
"rule",
"define",
"when_all",
"__call__",
"__init__",
"when_any",
"for",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "func",
"type": "statement"
},
{
"name": "rule",
"type": "statement"
},
{
"name": "state_name",
"type": "statement"
},
{
"name": "when_all",
"type": "function"
},
{
"name": "when_any",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.
|
1,912 | 40 | 13,970 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
state_name
| true |
statement
| 7 | 6 | false | false |
[
"rule",
"state_name",
"func",
"define",
"when_all",
"__call__",
"__init__",
"when_any",
"for",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "func",
"type": "statement"
},
{
"name": "rule",
"type": "statement"
},
{
"name": "state_name",
"type": "statement"
},
{
"name": "when_all",
"type": "function"
},
{
"name": "when_any",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.
|
1,918 | 40 | 14,766 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
triggers
| true |
statement
| 4 | 4 | false | true |
[
"states",
"triggers",
"state_name",
"define",
"__init__",
"__enter__",
"__exit__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "state_name",
"type": "statement"
},
{
"name": "states",
"type": "statement"
},
{
"name": "triggers",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.
|
1,919 | 40 | 15,061 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
states
| true |
statement
| 4 | 4 | false | true |
[
"states",
"triggers",
"state_name",
"define",
"__init__",
"__enter__",
"__exit__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "state_name",
"type": "statement"
},
{
"name": "states",
"type": "statement"
},
{
"name": "triggers",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.
|
1,920 | 40 | 15,123 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
states
| true |
statement
| 4 | 4 | false | false |
[
"states",
"state_name",
"triggers",
"define",
"__init__",
"__enter__",
"__exit__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "state_name",
"type": "statement"
},
{
"name": "states",
"type": "statement"
},
{
"name": "triggers",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.
|
1,921 | 40 | 15,313 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
state_name
| true |
statement
| 5 | 4 | false | false |
[
"state_name",
"states",
"triggers",
"define",
"for",
"__enter__",
"__exit__",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "state_name",
"type": "statement"
},
{
"name": "states",
"type": "statement"
},
{
"name": "triggers",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.
|
1,926 | 40 | 15,921 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
states
| true |
statement
| 4 | 4 | false | false |
[
"states",
"name",
"root",
"define",
"__init__",
"__enter__",
"__exit__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "root",
"type": "statement"
},
{
"name": "states",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.
|
1,927 | 40 | 16,085 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
name
| true |
statement
| 5 | 4 | false | false |
[
"states",
"name",
"root",
"define",
"for",
"__enter__",
"__exit__",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "root",
"type": "statement"
},
{
"name": "states",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.
|
1,933 | 40 | 16,810 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
func
| true |
statement
| 4 | 4 | false | false |
[
"func",
"stage_name",
"switches",
"define",
"__init__",
"__enter__",
"__exit__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "func",
"type": "statement"
},
{
"name": "stage_name",
"type": "statement"
},
{
"name": "switches",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.
|
1,934 | 40 | 16,841 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
func
| true |
statement
| 4 | 4 | false | false |
[
"func",
"stage_name",
"switches",
"define",
"__init__",
"__enter__",
"__exit__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "func",
"type": "statement"
},
{
"name": "stage_name",
"type": "statement"
},
{
"name": "switches",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.
|
1,935 | 40 | 16,873 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
func
| true |
statement
| 4 | 4 | false | false |
[
"func",
"stage_name",
"switches",
"define",
"__init__",
"__enter__",
"__exit__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "func",
"type": "statement"
},
{
"name": "stage_name",
"type": "statement"
},
{
"name": "switches",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.
|
1,936 | 40 | 16,938 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
func
| true |
statement
| 4 | 4 | false | false |
[
"func",
"stage_name",
"switches",
"define",
"__init__",
"__enter__",
"__exit__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "func",
"type": "statement"
},
{
"name": "stage_name",
"type": "statement"
},
{
"name": "switches",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.
|
1,937 | 40 | 17,038 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
func
| true |
statement
| 4 | 4 | false | false |
[
"func",
"switches",
"stage_name",
"define",
"__init__",
"__enter__",
"__exit__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "func",
"type": "statement"
},
{
"name": "stage_name",
"type": "statement"
},
{
"name": "switches",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.
|
1,938 | 40 | 17,271 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
switches
| true |
statement
| 5 | 4 | false | true |
[
"func",
"stage_name",
"switches",
"define",
"__init__",
"__enter__",
"__exit__",
"yield",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "func",
"type": "statement"
},
{
"name": "stage_name",
"type": "statement"
},
{
"name": "switches",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.
|
1,939 | 40 | 17,334 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
switches
| true |
statement
| 4 | 4 | false | false |
[
"switches",
"func",
"stage_name",
"define",
"__init__",
"__enter__",
"__exit__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "func",
"type": "statement"
},
{
"name": "stage_name",
"type": "statement"
},
{
"name": "switches",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.switches)):
to = {}
for switch in self.
|
1,940 | 40 | 17,870 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
stage_name
| true |
statement
| 5 | 4 | false | true |
[
"func",
"stage_name",
"switches",
"define",
"for",
"__enter__",
"__exit__",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "func",
"type": "statement"
},
{
"name": "stage_name",
"type": "statement"
},
{
"name": "switches",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.switches)):
to = {}
for switch in self.switches:
stage_name, switch_definition = switch.define()
if not switch_definition:
to = stage_name
break
elif 'all' in switch_definition:
switch_definition = {'all': switch_definition['all']}
elif 'any' in switch_definition:
switch_definition = {'any': switch_definition['any']}
to[stage_name] = switch_definition
new_definition['to'] = to
return self.
|
1,944 | 40 | 18,452 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
stages
| true |
statement
| 3 | 3 | false | true |
[
"stages",
"name",
"define",
"__init__",
"__exit__",
"__enter__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "stages",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.switches)):
to = {}
for switch in self.switches:
stage_name, switch_definition = switch.define()
if not switch_definition:
to = stage_name
break
elif 'all' in switch_definition:
switch_definition = {'all': switch_definition['all']}
elif 'any' in switch_definition:
switch_definition = {'any': switch_definition['any']}
to[stage_name] = switch_definition
new_definition['to'] = to
return self.stage_name, new_definition
class flowchart(object):
def __init__(self, name):
self.name = name
self.stages = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for stage in self.
|
1,945 | 40 | 18,615 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
name
| true |
statement
| 4 | 3 | false | false |
[
"name",
"stages",
"define",
"for",
"__init__",
"__enter__",
"__exit__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "stages",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__enter__",
"type": "function"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__exit__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.switches)):
to = {}
for switch in self.switches:
stage_name, switch_definition = switch.define()
if not switch_definition:
to = stage_name
break
elif 'all' in switch_definition:
switch_definition = {'all': switch_definition['all']}
elif 'any' in switch_definition:
switch_definition = {'any': switch_definition['any']}
to[stage_name] = switch_definition
new_definition['to'] = to
return self.stage_name, new_definition
class flowchart(object):
def __init__(self, name):
self.name = name
self.stages = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for stage in self.stages:
stage_name, stage_definition = stage.define()
new_definition[stage_name] = stage_definition
return '{0}$flow'.format(self.
|
1,946 | 40 | 19,388 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
commited
|
Host
| true |
class
| 13 | 23 | false | true |
[
"Host",
"logger",
"durable_rules_engine",
"Ruleset",
"To",
"Closure",
"Content",
"Flowchart",
"MessageNotHandledException",
"MessageObservedException",
"Promise",
"Statechart",
"_unix_now"
] |
[
{
"name": "Closure",
"type": "class"
},
{
"name": "Content",
"type": "class"
},
{
"name": "copy",
"type": "module"
},
{
"name": "datetime",
"type": "module"
},
{
"name": "durable_rules_engine",
"type": "module"
},
{
"name": "Flowchart",
"type": "class"
},
{
"name": "Host",
"type": "class"
},
{
"name": "inspect",
"type": "module"
},
{
"name": "json",
"type": "module"
},
{
"name": "logger",
"type": "instance"
},
{
"name": "MessageNotHandledException",
"type": "class"
},
{
"name": "MessageObservedException",
"type": "class"
},
{
"name": "os",
"type": "module"
},
{
"name": "Promise",
"type": "class"
},
{
"name": "random",
"type": "module"
},
{
"name": "Ruleset",
"type": "class"
},
{
"name": "Statechart",
"type": "class"
},
{
"name": "sys",
"type": "module"
},
{
"name": "threading",
"type": "module"
},
{
"name": "time",
"type": "module"
},
{
"name": "To",
"type": "class"
},
{
"name": "traceback",
"type": "module"
},
{
"name": "_unix_now",
"type": "function"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.switches)):
to = {}
for switch in self.switches:
stage_name, switch_definition = switch.define()
if not switch_definition:
to = stage_name
break
elif 'all' in switch_definition:
switch_definition = {'all': switch_definition['all']}
elif 'any' in switch_definition:
switch_definition = {'any': switch_definition['any']}
to[stage_name] = switch_definition
new_definition['to'] = to
return self.stage_name, new_definition
class flowchart(object):
def __init__(self, name):
self.name = name
self.stages = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for stage in self.stages:
stage_name, stage_definition = stage.define()
new_definition[stage_name] = stage_definition
return '{0}$flow'.format(self.name), new_definition
def timeout(name):
return all(avalue('base') << value('$m', '$timerName') == name,
avalue('timeout') << value('$m', '$time') >= avalue('base', '$baseTime'))
def count(value):
return {'count': value}
def pri(value):
return {'pri': value}
def cap(value):
return {'cap': value}
def distinct(value):
return {'dist': value}
def select(name):
if name in _rulesets:
return _rulesets[name]
raise Exception('Ruleset {0} not found'.format(name))
m = value('$m')
s = value('$s')
item = value('$i', '$i')
c = closure()
_rule_stack = []
_ruleset_stack = []
_rulesets = {}
_main_host = None
def get_host():
global _main_host
global _rulesets
if not _main_host:
_main_host = engine.
|
1,947 | 40 | 19,625 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
commited
|
register_rulesets
| true |
function
| 31 | 37 | false | true |
[
"post",
"get_facts",
"get_state",
"assert_fact",
"retract_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_ruleset",
"get_stored_messages_callback",
"load_ruleset",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.switches)):
to = {}
for switch in self.switches:
stage_name, switch_definition = switch.define()
if not switch_definition:
to = stage_name
break
elif 'all' in switch_definition:
switch_definition = {'all': switch_definition['all']}
elif 'any' in switch_definition:
switch_definition = {'any': switch_definition['any']}
to[stage_name] = switch_definition
new_definition['to'] = to
return self.stage_name, new_definition
class flowchart(object):
def __init__(self, name):
self.name = name
self.stages = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for stage in self.stages:
stage_name, stage_definition = stage.define()
new_definition[stage_name] = stage_definition
return '{0}$flow'.format(self.name), new_definition
def timeout(name):
return all(avalue('base') << value('$m', '$timerName') == name,
avalue('timeout') << value('$m', '$time') >= avalue('base', '$baseTime'))
def count(value):
return {'count': value}
def pri(value):
return {'pri': value}
def cap(value):
return {'cap': value}
def distinct(value):
return {'dist': value}
def select(name):
if name in _rulesets:
return _rulesets[name]
raise Exception('Ruleset {0} not found'.format(name))
m = value('$m')
s = value('$s')
item = value('$i', '$i')
c = closure()
_rule_stack = []
_ruleset_stack = []
_rulesets = {}
_main_host = None
def get_host():
global _main_host
global _rulesets
if not _main_host:
_main_host = engine.Host()
try:
ruleset_definitions = {}
for name, rset in _rulesets.items():
full_name, ruleset_definition = rset.define()
ruleset_definitions[full_name] = ruleset_definition
_main_host.
|
1,948 | 40 | 19,804 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
commited
|
post
| true |
function
| 31 | 37 | false | true |
[
"post_batch",
"get_facts",
"get_state",
"get_pending_events",
"post",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_idle_state_callback",
"get_queued_messages_callback",
"get_ruleset",
"get_stored_messages_callback",
"load_ruleset",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.switches)):
to = {}
for switch in self.switches:
stage_name, switch_definition = switch.define()
if not switch_definition:
to = stage_name
break
elif 'all' in switch_definition:
switch_definition = {'all': switch_definition['all']}
elif 'any' in switch_definition:
switch_definition = {'any': switch_definition['any']}
to[stage_name] = switch_definition
new_definition['to'] = to
return self.stage_name, new_definition
class flowchart(object):
def __init__(self, name):
self.name = name
self.stages = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for stage in self.stages:
stage_name, stage_definition = stage.define()
new_definition[stage_name] = stage_definition
return '{0}$flow'.format(self.name), new_definition
def timeout(name):
return all(avalue('base') << value('$m', '$timerName') == name,
avalue('timeout') << value('$m', '$time') >= avalue('base', '$baseTime'))
def count(value):
return {'count': value}
def pri(value):
return {'pri': value}
def cap(value):
return {'cap': value}
def distinct(value):
return {'dist': value}
def select(name):
if name in _rulesets:
return _rulesets[name]
raise Exception('Ruleset {0} not found'.format(name))
m = value('$m')
s = value('$s')
item = value('$i', '$i')
c = closure()
_rule_stack = []
_ruleset_stack = []
_rulesets = {}
_main_host = None
def get_host():
global _main_host
global _rulesets
if not _main_host:
_main_host = engine.Host()
try:
ruleset_definitions = {}
for name, rset in _rulesets.items():
full_name, ruleset_definition = rset.define()
ruleset_definitions[full_name] = ruleset_definition
_main_host.register_rulesets(ruleset_definitions)
finally:
_rulesets = {}
return _main_host
def post(ruleset_name, message, complete = None):
return get_host().
|
1,949 | 40 | 19,930 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
post_batch
| true |
function
| 31 | 37 | false | true |
[
"post",
"get_facts",
"get_state",
"get_pending_events",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_idle_state_callback",
"get_queued_messages_callback",
"get_ruleset",
"get_stored_messages_callback",
"load_ruleset",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.switches)):
to = {}
for switch in self.switches:
stage_name, switch_definition = switch.define()
if not switch_definition:
to = stage_name
break
elif 'all' in switch_definition:
switch_definition = {'all': switch_definition['all']}
elif 'any' in switch_definition:
switch_definition = {'any': switch_definition['any']}
to[stage_name] = switch_definition
new_definition['to'] = to
return self.stage_name, new_definition
class flowchart(object):
def __init__(self, name):
self.name = name
self.stages = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for stage in self.stages:
stage_name, stage_definition = stage.define()
new_definition[stage_name] = stage_definition
return '{0}$flow'.format(self.name), new_definition
def timeout(name):
return all(avalue('base') << value('$m', '$timerName') == name,
avalue('timeout') << value('$m', '$time') >= avalue('base', '$baseTime'))
def count(value):
return {'count': value}
def pri(value):
return {'pri': value}
def cap(value):
return {'cap': value}
def distinct(value):
return {'dist': value}
def select(name):
if name in _rulesets:
return _rulesets[name]
raise Exception('Ruleset {0} not found'.format(name))
m = value('$m')
s = value('$s')
item = value('$i', '$i')
c = closure()
_rule_stack = []
_ruleset_stack = []
_rulesets = {}
_main_host = None
def get_host():
global _main_host
global _rulesets
if not _main_host:
_main_host = engine.Host()
try:
ruleset_definitions = {}
for name, rset in _rulesets.items():
full_name, ruleset_definition = rset.define()
ruleset_definitions[full_name] = ruleset_definition
_main_host.register_rulesets(ruleset_definitions)
finally:
_rulesets = {}
return _main_host
def post(ruleset_name, message, complete = None):
return get_host().post(ruleset_name, message, complete)
def post_batch(ruleset_name, messages, complete = None):
return get_host().
|
1,950 | 40 | 20,056 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
assert_fact
| true |
function
| 31 | 37 | false | true |
[
"get_facts",
"retract_fact",
"assert_facts",
"retract_facts",
"post",
"assert_fact",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.switches)):
to = {}
for switch in self.switches:
stage_name, switch_definition = switch.define()
if not switch_definition:
to = stage_name
break
elif 'all' in switch_definition:
switch_definition = {'all': switch_definition['all']}
elif 'any' in switch_definition:
switch_definition = {'any': switch_definition['any']}
to[stage_name] = switch_definition
new_definition['to'] = to
return self.stage_name, new_definition
class flowchart(object):
def __init__(self, name):
self.name = name
self.stages = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for stage in self.stages:
stage_name, stage_definition = stage.define()
new_definition[stage_name] = stage_definition
return '{0}$flow'.format(self.name), new_definition
def timeout(name):
return all(avalue('base') << value('$m', '$timerName') == name,
avalue('timeout') << value('$m', '$time') >= avalue('base', '$baseTime'))
def count(value):
return {'count': value}
def pri(value):
return {'pri': value}
def cap(value):
return {'cap': value}
def distinct(value):
return {'dist': value}
def select(name):
if name in _rulesets:
return _rulesets[name]
raise Exception('Ruleset {0} not found'.format(name))
m = value('$m')
s = value('$s')
item = value('$i', '$i')
c = closure()
_rule_stack = []
_ruleset_stack = []
_rulesets = {}
_main_host = None
def get_host():
global _main_host
global _rulesets
if not _main_host:
_main_host = engine.Host()
try:
ruleset_definitions = {}
for name, rset in _rulesets.items():
full_name, ruleset_definition = rset.define()
ruleset_definitions[full_name] = ruleset_definition
_main_host.register_rulesets(ruleset_definitions)
finally:
_rulesets = {}
return _main_host
def post(ruleset_name, message, complete = None):
return get_host().post(ruleset_name, message, complete)
def post_batch(ruleset_name, messages, complete = None):
return get_host().post_batch(ruleset_name, messages, complete)
def assert_fact(ruleset_name, fact, complete = None):
return get_host().
|
1,951 | 40 | 20,181 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
assert_facts
| true |
function
| 31 | 37 | false | true |
[
"assert_fact",
"get_facts",
"retract_fact",
"retract_facts",
"post",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.switches)):
to = {}
for switch in self.switches:
stage_name, switch_definition = switch.define()
if not switch_definition:
to = stage_name
break
elif 'all' in switch_definition:
switch_definition = {'all': switch_definition['all']}
elif 'any' in switch_definition:
switch_definition = {'any': switch_definition['any']}
to[stage_name] = switch_definition
new_definition['to'] = to
return self.stage_name, new_definition
class flowchart(object):
def __init__(self, name):
self.name = name
self.stages = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for stage in self.stages:
stage_name, stage_definition = stage.define()
new_definition[stage_name] = stage_definition
return '{0}$flow'.format(self.name), new_definition
def timeout(name):
return all(avalue('base') << value('$m', '$timerName') == name,
avalue('timeout') << value('$m', '$time') >= avalue('base', '$baseTime'))
def count(value):
return {'count': value}
def pri(value):
return {'pri': value}
def cap(value):
return {'cap': value}
def distinct(value):
return {'dist': value}
def select(name):
if name in _rulesets:
return _rulesets[name]
raise Exception('Ruleset {0} not found'.format(name))
m = value('$m')
s = value('$s')
item = value('$i', '$i')
c = closure()
_rule_stack = []
_ruleset_stack = []
_rulesets = {}
_main_host = None
def get_host():
global _main_host
global _rulesets
if not _main_host:
_main_host = engine.Host()
try:
ruleset_definitions = {}
for name, rset in _rulesets.items():
full_name, ruleset_definition = rset.define()
ruleset_definitions[full_name] = ruleset_definition
_main_host.register_rulesets(ruleset_definitions)
finally:
_rulesets = {}
return _main_host
def post(ruleset_name, message, complete = None):
return get_host().post(ruleset_name, message, complete)
def post_batch(ruleset_name, messages, complete = None):
return get_host().post_batch(ruleset_name, messages, complete)
def assert_fact(ruleset_name, fact, complete = None):
return get_host().assert_fact(ruleset_name, fact, complete)
def assert_facts(ruleset_name, facts, complete = None):
return get_host().
|
1,952 | 40 | 20,307 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
infile
|
retract_fact
| true |
function
| 31 | 37 | false | true |
[
"get_facts",
"assert_fact",
"retract_facts",
"assert_facts",
"post",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.switches)):
to = {}
for switch in self.switches:
stage_name, switch_definition = switch.define()
if not switch_definition:
to = stage_name
break
elif 'all' in switch_definition:
switch_definition = {'all': switch_definition['all']}
elif 'any' in switch_definition:
switch_definition = {'any': switch_definition['any']}
to[stage_name] = switch_definition
new_definition['to'] = to
return self.stage_name, new_definition
class flowchart(object):
def __init__(self, name):
self.name = name
self.stages = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for stage in self.stages:
stage_name, stage_definition = stage.define()
new_definition[stage_name] = stage_definition
return '{0}$flow'.format(self.name), new_definition
def timeout(name):
return all(avalue('base') << value('$m', '$timerName') == name,
avalue('timeout') << value('$m', '$time') >= avalue('base', '$baseTime'))
def count(value):
return {'count': value}
def pri(value):
return {'pri': value}
def cap(value):
return {'cap': value}
def distinct(value):
return {'dist': value}
def select(name):
if name in _rulesets:
return _rulesets[name]
raise Exception('Ruleset {0} not found'.format(name))
m = value('$m')
s = value('$s')
item = value('$i', '$i')
c = closure()
_rule_stack = []
_ruleset_stack = []
_rulesets = {}
_main_host = None
def get_host():
global _main_host
global _rulesets
if not _main_host:
_main_host = engine.Host()
try:
ruleset_definitions = {}
for name, rset in _rulesets.items():
full_name, ruleset_definition = rset.define()
ruleset_definitions[full_name] = ruleset_definition
_main_host.register_rulesets(ruleset_definitions)
finally:
_rulesets = {}
return _main_host
def post(ruleset_name, message, complete = None):
return get_host().post(ruleset_name, message, complete)
def post_batch(ruleset_name, messages, complete = None):
return get_host().post_batch(ruleset_name, messages, complete)
def assert_fact(ruleset_name, fact, complete = None):
return get_host().assert_fact(ruleset_name, fact, complete)
def assert_facts(ruleset_name, facts, complete = None):
return get_host().assert_facts(ruleset_name, facts, complete)
def retract_fact(ruleset_name, fact, complete = None):
return get_host().
|
1,953 | 40 | 20,434 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
retract_facts
| true |
function
| 31 | 37 | false | true |
[
"get_facts",
"retract_fact",
"assert_fact",
"assert_facts",
"post",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.switches)):
to = {}
for switch in self.switches:
stage_name, switch_definition = switch.define()
if not switch_definition:
to = stage_name
break
elif 'all' in switch_definition:
switch_definition = {'all': switch_definition['all']}
elif 'any' in switch_definition:
switch_definition = {'any': switch_definition['any']}
to[stage_name] = switch_definition
new_definition['to'] = to
return self.stage_name, new_definition
class flowchart(object):
def __init__(self, name):
self.name = name
self.stages = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for stage in self.stages:
stage_name, stage_definition = stage.define()
new_definition[stage_name] = stage_definition
return '{0}$flow'.format(self.name), new_definition
def timeout(name):
return all(avalue('base') << value('$m', '$timerName') == name,
avalue('timeout') << value('$m', '$time') >= avalue('base', '$baseTime'))
def count(value):
return {'count': value}
def pri(value):
return {'pri': value}
def cap(value):
return {'cap': value}
def distinct(value):
return {'dist': value}
def select(name):
if name in _rulesets:
return _rulesets[name]
raise Exception('Ruleset {0} not found'.format(name))
m = value('$m')
s = value('$s')
item = value('$i', '$i')
c = closure()
_rule_stack = []
_ruleset_stack = []
_rulesets = {}
_main_host = None
def get_host():
global _main_host
global _rulesets
if not _main_host:
_main_host = engine.Host()
try:
ruleset_definitions = {}
for name, rset in _rulesets.items():
full_name, ruleset_definition = rset.define()
ruleset_definitions[full_name] = ruleset_definition
_main_host.register_rulesets(ruleset_definitions)
finally:
_rulesets = {}
return _main_host
def post(ruleset_name, message, complete = None):
return get_host().post(ruleset_name, message, complete)
def post_batch(ruleset_name, messages, complete = None):
return get_host().post_batch(ruleset_name, messages, complete)
def assert_fact(ruleset_name, fact, complete = None):
return get_host().assert_fact(ruleset_name, fact, complete)
def assert_facts(ruleset_name, facts, complete = None):
return get_host().assert_facts(ruleset_name, facts, complete)
def retract_fact(ruleset_name, fact, complete = None):
return get_host().retract_fact(ruleset_name, fact, complete)
def retract_facts(ruleset_name, facts, complete = None):
return get_host().
|
1,954 | 40 | 20,555 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
update_state
| true |
function
| 31 | 37 | false | true |
[
"get_state",
"delete_state",
"post",
"get_facts",
"get_pending_events",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"get_action",
"get_idle_state_callback",
"get_queued_messages_callback",
"get_ruleset",
"get_stored_messages_callback",
"load_ruleset",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.switches)):
to = {}
for switch in self.switches:
stage_name, switch_definition = switch.define()
if not switch_definition:
to = stage_name
break
elif 'all' in switch_definition:
switch_definition = {'all': switch_definition['all']}
elif 'any' in switch_definition:
switch_definition = {'any': switch_definition['any']}
to[stage_name] = switch_definition
new_definition['to'] = to
return self.stage_name, new_definition
class flowchart(object):
def __init__(self, name):
self.name = name
self.stages = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for stage in self.stages:
stage_name, stage_definition = stage.define()
new_definition[stage_name] = stage_definition
return '{0}$flow'.format(self.name), new_definition
def timeout(name):
return all(avalue('base') << value('$m', '$timerName') == name,
avalue('timeout') << value('$m', '$time') >= avalue('base', '$baseTime'))
def count(value):
return {'count': value}
def pri(value):
return {'pri': value}
def cap(value):
return {'cap': value}
def distinct(value):
return {'dist': value}
def select(name):
if name in _rulesets:
return _rulesets[name]
raise Exception('Ruleset {0} not found'.format(name))
m = value('$m')
s = value('$s')
item = value('$i', '$i')
c = closure()
_rule_stack = []
_ruleset_stack = []
_rulesets = {}
_main_host = None
def get_host():
global _main_host
global _rulesets
if not _main_host:
_main_host = engine.Host()
try:
ruleset_definitions = {}
for name, rset in _rulesets.items():
full_name, ruleset_definition = rset.define()
ruleset_definitions[full_name] = ruleset_definition
_main_host.register_rulesets(ruleset_definitions)
finally:
_rulesets = {}
return _main_host
def post(ruleset_name, message, complete = None):
return get_host().post(ruleset_name, message, complete)
def post_batch(ruleset_name, messages, complete = None):
return get_host().post_batch(ruleset_name, messages, complete)
def assert_fact(ruleset_name, fact, complete = None):
return get_host().assert_fact(ruleset_name, fact, complete)
def assert_facts(ruleset_name, facts, complete = None):
return get_host().assert_facts(ruleset_name, facts, complete)
def retract_fact(ruleset_name, fact, complete = None):
return get_host().retract_fact(ruleset_name, fact, complete)
def retract_facts(ruleset_name, facts, complete = None):
return get_host().retract_facts(ruleset_name, facts, complete)
def update_state(ruleset_name, state, complete = None):
get_host().
|
1,955 | 40 | 20,663 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
infile
|
get_state
| true |
function
| 31 | 37 | false | true |
[
"delete_state",
"update_state",
"post",
"get_facts",
"get_pending_events",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"get_action",
"get_idle_state_callback",
"get_queued_messages_callback",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.switches)):
to = {}
for switch in self.switches:
stage_name, switch_definition = switch.define()
if not switch_definition:
to = stage_name
break
elif 'all' in switch_definition:
switch_definition = {'all': switch_definition['all']}
elif 'any' in switch_definition:
switch_definition = {'any': switch_definition['any']}
to[stage_name] = switch_definition
new_definition['to'] = to
return self.stage_name, new_definition
class flowchart(object):
def __init__(self, name):
self.name = name
self.stages = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for stage in self.stages:
stage_name, stage_definition = stage.define()
new_definition[stage_name] = stage_definition
return '{0}$flow'.format(self.name), new_definition
def timeout(name):
return all(avalue('base') << value('$m', '$timerName') == name,
avalue('timeout') << value('$m', '$time') >= avalue('base', '$baseTime'))
def count(value):
return {'count': value}
def pri(value):
return {'pri': value}
def cap(value):
return {'cap': value}
def distinct(value):
return {'dist': value}
def select(name):
if name in _rulesets:
return _rulesets[name]
raise Exception('Ruleset {0} not found'.format(name))
m = value('$m')
s = value('$s')
item = value('$i', '$i')
c = closure()
_rule_stack = []
_ruleset_stack = []
_rulesets = {}
_main_host = None
def get_host():
global _main_host
global _rulesets
if not _main_host:
_main_host = engine.Host()
try:
ruleset_definitions = {}
for name, rset in _rulesets.items():
full_name, ruleset_definition = rset.define()
ruleset_definitions[full_name] = ruleset_definition
_main_host.register_rulesets(ruleset_definitions)
finally:
_rulesets = {}
return _main_host
def post(ruleset_name, message, complete = None):
return get_host().post(ruleset_name, message, complete)
def post_batch(ruleset_name, messages, complete = None):
return get_host().post_batch(ruleset_name, messages, complete)
def assert_fact(ruleset_name, fact, complete = None):
return get_host().assert_fact(ruleset_name, fact, complete)
def assert_facts(ruleset_name, facts, complete = None):
return get_host().assert_facts(ruleset_name, facts, complete)
def retract_fact(ruleset_name, fact, complete = None):
return get_host().retract_fact(ruleset_name, fact, complete)
def retract_facts(ruleset_name, facts, complete = None):
return get_host().retract_facts(ruleset_name, facts, complete)
def update_state(ruleset_name, state, complete = None):
get_host().update_state(ruleset_name, state, complete)
def get_state(ruleset_name, sid = None):
return get_host().
|
1,956 | 40 | 20,752 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
delete_state
| true |
function
| 31 | 37 | false | true |
[
"get_state",
"update_state",
"post",
"get_facts",
"get_pending_events",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_idle_state_callback",
"get_queued_messages_callback",
"get_ruleset",
"get_stored_messages_callback",
"load_ruleset",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.switches)):
to = {}
for switch in self.switches:
stage_name, switch_definition = switch.define()
if not switch_definition:
to = stage_name
break
elif 'all' in switch_definition:
switch_definition = {'all': switch_definition['all']}
elif 'any' in switch_definition:
switch_definition = {'any': switch_definition['any']}
to[stage_name] = switch_definition
new_definition['to'] = to
return self.stage_name, new_definition
class flowchart(object):
def __init__(self, name):
self.name = name
self.stages = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for stage in self.stages:
stage_name, stage_definition = stage.define()
new_definition[stage_name] = stage_definition
return '{0}$flow'.format(self.name), new_definition
def timeout(name):
return all(avalue('base') << value('$m', '$timerName') == name,
avalue('timeout') << value('$m', '$time') >= avalue('base', '$baseTime'))
def count(value):
return {'count': value}
def pri(value):
return {'pri': value}
def cap(value):
return {'cap': value}
def distinct(value):
return {'dist': value}
def select(name):
if name in _rulesets:
return _rulesets[name]
raise Exception('Ruleset {0} not found'.format(name))
m = value('$m')
s = value('$s')
item = value('$i', '$i')
c = closure()
_rule_stack = []
_ruleset_stack = []
_rulesets = {}
_main_host = None
def get_host():
global _main_host
global _rulesets
if not _main_host:
_main_host = engine.Host()
try:
ruleset_definitions = {}
for name, rset in _rulesets.items():
full_name, ruleset_definition = rset.define()
ruleset_definitions[full_name] = ruleset_definition
_main_host.register_rulesets(ruleset_definitions)
finally:
_rulesets = {}
return _main_host
def post(ruleset_name, message, complete = None):
return get_host().post(ruleset_name, message, complete)
def post_batch(ruleset_name, messages, complete = None):
return get_host().post_batch(ruleset_name, messages, complete)
def assert_fact(ruleset_name, fact, complete = None):
return get_host().assert_fact(ruleset_name, fact, complete)
def assert_facts(ruleset_name, facts, complete = None):
return get_host().assert_facts(ruleset_name, facts, complete)
def retract_fact(ruleset_name, fact, complete = None):
return get_host().retract_fact(ruleset_name, fact, complete)
def retract_facts(ruleset_name, facts, complete = None):
return get_host().retract_facts(ruleset_name, facts, complete)
def update_state(ruleset_name, state, complete = None):
get_host().update_state(ruleset_name, state, complete)
def get_state(ruleset_name, sid = None):
return get_host().get_state(ruleset_name, sid)
def delete_state(ruleset_name, sid = None):
get_host().
|
1,957 | 40 | 20,848 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
get_facts
| true |
function
| 31 | 37 | false | true |
[
"assert_fact",
"retract_fact",
"assert_facts",
"retract_facts",
"post",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.switches)):
to = {}
for switch in self.switches:
stage_name, switch_definition = switch.define()
if not switch_definition:
to = stage_name
break
elif 'all' in switch_definition:
switch_definition = {'all': switch_definition['all']}
elif 'any' in switch_definition:
switch_definition = {'any': switch_definition['any']}
to[stage_name] = switch_definition
new_definition['to'] = to
return self.stage_name, new_definition
class flowchart(object):
def __init__(self, name):
self.name = name
self.stages = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for stage in self.stages:
stage_name, stage_definition = stage.define()
new_definition[stage_name] = stage_definition
return '{0}$flow'.format(self.name), new_definition
def timeout(name):
return all(avalue('base') << value('$m', '$timerName') == name,
avalue('timeout') << value('$m', '$time') >= avalue('base', '$baseTime'))
def count(value):
return {'count': value}
def pri(value):
return {'pri': value}
def cap(value):
return {'cap': value}
def distinct(value):
return {'dist': value}
def select(name):
if name in _rulesets:
return _rulesets[name]
raise Exception('Ruleset {0} not found'.format(name))
m = value('$m')
s = value('$s')
item = value('$i', '$i')
c = closure()
_rule_stack = []
_ruleset_stack = []
_rulesets = {}
_main_host = None
def get_host():
global _main_host
global _rulesets
if not _main_host:
_main_host = engine.Host()
try:
ruleset_definitions = {}
for name, rset in _rulesets.items():
full_name, ruleset_definition = rset.define()
ruleset_definitions[full_name] = ruleset_definition
_main_host.register_rulesets(ruleset_definitions)
finally:
_rulesets = {}
return _main_host
def post(ruleset_name, message, complete = None):
return get_host().post(ruleset_name, message, complete)
def post_batch(ruleset_name, messages, complete = None):
return get_host().post_batch(ruleset_name, messages, complete)
def assert_fact(ruleset_name, fact, complete = None):
return get_host().assert_fact(ruleset_name, fact, complete)
def assert_facts(ruleset_name, facts, complete = None):
return get_host().assert_facts(ruleset_name, facts, complete)
def retract_fact(ruleset_name, fact, complete = None):
return get_host().retract_fact(ruleset_name, fact, complete)
def retract_facts(ruleset_name, facts, complete = None):
return get_host().retract_facts(ruleset_name, facts, complete)
def update_state(ruleset_name, state, complete = None):
get_host().update_state(ruleset_name, state, complete)
def get_state(ruleset_name, sid = None):
return get_host().get_state(ruleset_name, sid)
def delete_state(ruleset_name, sid = None):
get_host().delete_state(ruleset_name, sid)
def get_facts(ruleset_name, sid = None):
return get_host().
|
1,958 | 40 | 20,950 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
get_pending_events
| true |
function
| 31 | 37 | false | true |
[
"post",
"get_facts",
"get_state",
"assert_fact",
"retract_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_ruleset",
"get_stored_messages_callback",
"load_ruleset",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self._set_right('$add', other)
def __sub__(self, other):
return self._set_right('$sub', other)
def __mul__(self, other):
return self._set_right('$mul', other)
def __div__(self, other):
return self._set_right('$div', other)
def __truediv__(self, other):
return self._set_right('$div', other)
def __lshift__(self, other):
other.alias = self._name
return other
def __getattr__(self, name):
if self._left:
self._left = '{0}.{1}'.format(self._left, name)
else:
self._left = name
return self
def __lt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __le__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __gt__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ge__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __eq__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __ne__(self, other):
raise Exception('Only binary arithmetic operators supported')
def __neg__(self):
raise Exception('Only binary arithmetic operators supported')
def __pos__(self):
raise Exception('Only binary arithmetic operators supported')
def _set_right(self, op, other):
if self._right:
self._left = avalue(self._name, self._left, self._sid, self._op, self._right)
self._op = op
self._right = other
return self
def define(self, parent_name = None):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._name))
if self._name == '$s':
raise Exception('s not allowed as rvalue')
if not self._op:
if self._sid:
return {self._name: {'name': self._left, 'id': self._sid}}
else:
return {self._name: self._left}
left_definition = None
if isinstance(self._left, avalue):
left_definition = self._left.define()
else:
left_definition = {self._name: self._left}
righ_definition = self._right
if isinstance(self._right, avalue):
righ_definition = self._right.define()
return {self._op: {'$l': left_definition, '$r': righ_definition}}
class closure(object):
def __getattr__(self, name):
return avalue(name)
class value(object):
def __init__(self, vtype = None, left = None, op = None, right = None, alias = None):
self.alias = alias
self._type = vtype
self._left = left
self._op = op
self._right = right
def __lt__(self, other):
return value(self._type, self._left, '$lt', other, self.alias)
def __le__(self, other):
return value(self._type, self._left, '$lte', other, self.alias)
def __gt__(self, other):
return value(self._type, self._left, '$gt', other, self.alias)
def __ge__(self, other):
return value(self._type, self._left, '$gte', other, self.alias)
def __eq__(self, other):
return value(self._type, self._left, '$eq', other, self.alias)
def __ne__(self, other):
return value(self._type, self._left, '$neq', other, self.alias)
def __neg__(self):
return value(self._type, self._left, '$nex', None, self.alias)
def __pos__(self):
return value(self._type, self._left, '$ex', None, self.alias)
def allItems(self, other):
return value(self._type, self._left, '$iall', other, self.alias)
def anyItem(self, other):
return value(self._type, self._left, '$iany', other, self.alias)
def matches(self, other):
return value(self._type, self._left, '$mt', other, self.alias)
def imatches(self, other):
return value(self._type, self._left, '$imt', other, self.alias)
def __and__(self, other):
return value(self._type, self, '$and', other, self.alias)
def __or__(self, other):
return value(self._type, self, '$or', other, self.alias)
def __add__(self, other):
return avalue(self._type, self._left, None, '$add', other)
def __sub__(self, other):
return avalue(self._type, self._left, None, '$sub', other)
def __mul__(self, other):
return avalue(self._type, self._left, None, '$mul', other)
def __div__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __truediv__(self, other):
return avalue(self._type, self._left, None, '$div', other)
def __getattr__(self, name):
if self._type:
if self._left:
return value(self._type, '{0}.{1}'.format(self._left, name))
else:
return value(self._type, name)
else:
return value(self.alias, name)
def define(self):
if not self._left:
raise Exception('Property name for {0} not defined'.format(self._type))
new_definition = None
right_definition = self._right
if isinstance(self._right, value) or isinstance(self._right, avalue):
right_definition = right_definition.define();
if self._op == '$or' or self._op == '$and':
left_definition = self._left.define()
if not self._op in left_definition:
left_definition = [left_definition, right_definition]
else:
left_definition = left_definition[self._op]
left_definition.append(right_definition)
new_definition = {self._op: left_definition}
elif self._op == '$nex' or self._op == '$ex':
new_definition = {self._op: {self._left: 1}}
elif self._op == '$eq':
new_definition = {self._left: right_definition}
elif not self._op:
if self._type == '$s':
raise Exception('s not allowed as rvalue')
logger.debug('defining %s, %s', self._type, self._left)
new_definition = {self._type: self._left}
else:
new_definition = {self._op: {self._left: right_definition}}
if self._type == '$s':
return {'$and': [new_definition, {'$s': 1}]}
else:
return new_definition
class run(object):
def __init__(self, func):
if len(_rule_stack) > 0:
_rule_stack[-1].func = [func]
else:
raise Exception('Invalid rule context')
self.func = func
class rule(object):
def __init__(self, operator, multi, *args):
self.operator = operator
self.multi = multi
self.alias = None
if len(_ruleset_stack) and isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
if not len(args):
raise Exception('Invalid number of arguments')
self.count = None
self.pri = None
self.cap = None
self.dist = None
self.func = []
new_args = []
for arg in args:
if isinstance(arg, dict):
if 'count' in arg:
self.count = arg['count']
elif 'pri' in arg:
self.pri = arg['pri']
elif 'cap' in arg:
self.cap = arg['cap']
elif 'dist' in arg:
self.dist = arg['dist']
else:
self.func = arg
elif isinstance(arg, value) or isinstance(arg, rule):
new_args.append(arg)
else:
self.func = arg
if not multi:
self.expression = new_args[0]
else:
self.expression = new_args
def __enter__(self):
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_rule_stack.pop()
def __call__(self, *args):
if (len(args) == 1 and hasattr(args[0], '__call__')):
self.func = [args[0]]
return self
def define(self, parent_name = None):
defined_expression = None
if not self.multi:
defined_expression = self.expression.define()
else:
index = 0
defined_expression = []
for current_expression in self.expression:
new_expression = None
name = None
if current_expression.alias:
name = current_expression.alias
elif len(self.expression) == 1:
if parent_name:
name = '{0}.m'.format(parent_name)
else:
name = 'm'
else:
if parent_name:
name = '{0}.m_{1}'.format(parent_name, index)
else:
name = 'm_{0}'.format(index)
if isinstance(current_expression, all):
new_expression = {'{0}$all'.format(name): current_expression.define(name)['all']}
elif isinstance(current_expression, any):
new_expression = {'{0}$any'.format(name): current_expression.define(name)['any']}
elif isinstance(current_expression, none):
new_expression = {'{0}$not'.format(name): current_expression.define()['none'][0]['m']}
else:
new_expression = {name: current_expression.define()}
defined_expression.append(new_expression)
index += 1
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
defined_expression = {self.operator: defined_expression, 'run': self.func[0]}
elif self.operator:
defined_expression = {self.operator: defined_expression}
if self.count:
defined_expression['count'] = self.count
if self.pri:
defined_expression['pri'] = self.pri
if self.cap:
defined_expression['cap'] = self.cap
if self.dist == True:
defined_expression['dist'] = 1
if self.dist == False:
defined_expression['dist'] = 0
return defined_expression
class when_all(rule):
def __init__(self, *args):
super(when_all, self).__init__('all', True, *args)
class when_any(rule):
def __init__(self, *args):
super(when_any, self).__init__('any', True, *args)
class all(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(all, self).__init__('all', True, *args)
_ruleset_stack.pop()
class any(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(any, self).__init__('any', True, *args)
_ruleset_stack.pop()
class none(rule):
def __init__(self, *args):
_ruleset_stack.append(self)
super(none, self).__init__('none', True, *args)
_ruleset_stack.pop()
class when_start(object):
def __init__(self, func):
if isinstance(_ruleset_stack[-1], ruleset):
_ruleset_stack[-1].rules.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], flowchart):
_ruleset_stack[-1].stages.append(self)
self.func = func
def __call__(self, *args):
return self.func(*args)
class ruleset(object):
def __init__(self, name):
self.name = name
self.rules = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for rule in self.rules:
new_definition['r_{0}'.format(index)] = rule.define()
index += 1
return self.name, new_definition
class to(object):
def __init__(self, state_name, func = None):
if not len(_ruleset_stack):
raise Exception('Invalid state context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].triggers.append(self)
elif isinstance(_ruleset_stack[-1], stage):
_ruleset_stack[-1].switches.append(self)
else:
raise Exception('Invalid state context')
self.state_name = state_name
self.rule = None
self.func = func
def when_all(self, *args):
self.rule = rule('all', True, *args)
return self.rule
def when_any(self, *args):
self.rule = rule('any', True, *args)
return self.rule
def __call__(self, *args):
if len(args) == 1:
if isinstance(args[0], rule):
self.rule = args[0]
elif hasattr(args[0], '__call__'):
self.func = args[0]
return self
def define(self):
if self.rule:
return self.state_name, self.rule.define()
else:
if self.func:
return self.state_name, {'run': self.func}
else:
return self.state_name, None
class state(object):
def __init__(self, state_name):
if not len(_ruleset_stack):
raise Exception('Invalid statechart context')
if isinstance(_ruleset_stack[-1], state):
_ruleset_stack[-1].states.append(self)
elif isinstance(_ruleset_stack[-1], statechart):
_ruleset_stack[-1].states.append(self)
else:
raise Exception('Invalid statechart context')
self.state_name = state_name
self.triggers = []
self.states = []
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
index = 0
new_definition = {}
for trigger in self.triggers:
trigger_to, trigger_rule = trigger.define()
if not trigger_rule:
trigger_rule = {}
trigger_rule['to'] = trigger_to
new_definition['t_{0}'.format(index)] = trigger_rule
index += 1
if len(self.states):
chart = {}
for state in self.states:
state_name, state_definition = state.define()
chart[state_name] = state_definition
new_definition['$chart'] = chart
return self.state_name, new_definition
class statechart(object):
def __init__(self, name):
self.name = name
self.states = []
self.root = True
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for state in self.states:
state_name, state_definition = state.define()
new_definition[state_name] = state_definition
return '{0}$state'.format(self.name), new_definition
class stage(object):
def __init__(self, stage_name, func = None):
if not len(_ruleset_stack) or not isinstance(_ruleset_stack[-1], flowchart):
raise Exception('Invalid flowchart context')
_ruleset_stack[-1].stages.append(self)
self.stage_name = stage_name
if func:
self.func = [func]
else:
self.func = []
self.switches = []
def __enter__(self):
_ruleset_stack.append(self)
_rule_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
_rule_stack.pop()
def define(self):
new_definition = {}
if len(self.func):
if len(self.func) == 1 and not hasattr(self.func[0], 'define'):
new_definition['run'] = self.func[0]
else:
ruleset_definitions = {}
for rset in self.func:
ruleset_name, ruleset_definition = rset.define()
ruleset_definitions[ruleset_name] = ruleset_definition
new_definition['run'] = ruleset_definitions
if (len(self.switches)):
to = {}
for switch in self.switches:
stage_name, switch_definition = switch.define()
if not switch_definition:
to = stage_name
break
elif 'all' in switch_definition:
switch_definition = {'all': switch_definition['all']}
elif 'any' in switch_definition:
switch_definition = {'any': switch_definition['any']}
to[stage_name] = switch_definition
new_definition['to'] = to
return self.stage_name, new_definition
class flowchart(object):
def __init__(self, name):
self.name = name
self.stages = []
if not len(_ruleset_stack):
_rulesets[name] = self
elif len(_rule_stack) > 0:
_rule_stack[-1].func.append(self)
else:
raise Exception('Invalid rule context')
def __enter__(self):
_ruleset_stack.append(self)
def __exit__(self, exc_type, exc_value, traceback):
_ruleset_stack.pop()
def define(self):
new_definition = {}
for stage in self.stages:
stage_name, stage_definition = stage.define()
new_definition[stage_name] = stage_definition
return '{0}$flow'.format(self.name), new_definition
def timeout(name):
return all(avalue('base') << value('$m', '$timerName') == name,
avalue('timeout') << value('$m', '$time') >= avalue('base', '$baseTime'))
def count(value):
return {'count': value}
def pri(value):
return {'pri': value}
def cap(value):
return {'cap': value}
def distinct(value):
return {'dist': value}
def select(name):
if name in _rulesets:
return _rulesets[name]
raise Exception('Ruleset {0} not found'.format(name))
m = value('$m')
s = value('$s')
item = value('$i', '$i')
c = closure()
_rule_stack = []
_ruleset_stack = []
_rulesets = {}
_main_host = None
def get_host():
global _main_host
global _rulesets
if not _main_host:
_main_host = engine.Host()
try:
ruleset_definitions = {}
for name, rset in _rulesets.items():
full_name, ruleset_definition = rset.define()
ruleset_definitions[full_name] = ruleset_definition
_main_host.register_rulesets(ruleset_definitions)
finally:
_rulesets = {}
return _main_host
def post(ruleset_name, message, complete = None):
return get_host().post(ruleset_name, message, complete)
def post_batch(ruleset_name, messages, complete = None):
return get_host().post_batch(ruleset_name, messages, complete)
def assert_fact(ruleset_name, fact, complete = None):
return get_host().assert_fact(ruleset_name, fact, complete)
def assert_facts(ruleset_name, facts, complete = None):
return get_host().assert_facts(ruleset_name, facts, complete)
def retract_fact(ruleset_name, fact, complete = None):
return get_host().retract_fact(ruleset_name, fact, complete)
def retract_facts(ruleset_name, facts, complete = None):
return get_host().retract_facts(ruleset_name, facts, complete)
def update_state(ruleset_name, state, complete = None):
get_host().update_state(ruleset_name, state, complete)
def get_state(ruleset_name, sid = None):
return get_host().get_state(ruleset_name, sid)
def delete_state(ruleset_name, sid = None):
get_host().delete_state(ruleset_name, sid)
def get_facts(ruleset_name, sid = None):
return get_host().get_facts(ruleset_name, sid)
def get_pending_events(ruleset_name, sid = None):
return get_host().
|
1,966 | 41 | 481 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
infile
|
_load_source
| true |
function
| 15 | 15 | true | true |
[
"console",
"stage_file",
"source_file",
"stage_file_obj",
"name",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"content",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"tests",
"update_report",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self.
|
1,967 | 41 | 540 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
Unknown
|
console
| true |
statement
| 15 | 15 | false | true |
[
"stage_file",
"name",
"console",
"content",
"source_file",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"stage_file_obj",
"tests",
"update_report",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.
|
1,968 | 41 | 606 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
Unknown
|
stage_file
| true |
statement
| 15 | 15 | false | true |
[
"stage_file",
"console",
"source_file",
"content",
"name",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"stage_file_obj",
"tests",
"update_report",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.console.rule(f'[bold green][Process stage] {os.path.basename(self.
|
1,969 | 41 | 639 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
Unknown
|
name
| true |
statement
| 15 | 15 | false | true |
[
"name",
"stage_file",
"stage_file_obj",
"source_file",
"console",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"content",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"tests",
"update_report",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.console.rule(f'[bold green][Process stage] {os.path.basename(self.stage_file).split(".")[0]}:{self.
|
1,970 | 41 | 774 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
Unknown
|
stage_file
| true |
statement
| 15 | 15 | false | false |
[
"stage_file",
"name",
"stage_file_obj",
"source_file",
"content",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"console",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"tests",
"update_report",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.console.rule(f'[bold green][Process stage] {os.path.basename(self.stage_file).split(".")[0]}:{self.name}',
align='left')
def _show_result(self, error=None):
stage_name = f'{os.path.basename(self.
|
1,971 | 41 | 807 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
Unknown
|
name
| true |
statement
| 15 | 15 | false | false |
[
"name",
"stage_file_obj",
"stage_file",
"source_file",
"content",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"console",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"tests",
"update_report",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.console.rule(f'[bold green][Process stage] {os.path.basename(self.stage_file).split(".")[0]}:{self.name}',
align='left')
def _show_result(self, error=None):
stage_name = f'{os.path.basename(self.stage_file).split(".")[0]}:{self.
|
1,972 | 41 | 933 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
Unknown
|
console
| true |
statement
| 15 | 15 | false | false |
[
"stage_file",
"name",
"stage_file_obj",
"console",
"content",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"source_file",
"tests",
"update_report",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.console.rule(f'[bold green][Process stage] {os.path.basename(self.stage_file).split(".")[0]}:{self.name}',
align='left')
def _show_result(self, error=None):
stage_name = f'{os.path.basename(self.stage_file).split(".")[0]}:{self.name}'
if error is not None:
click.echo(f'Skipped stage [{stage_name}] Error: {error}')
self.
|
1,973 | 41 | 1,027 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
Unknown
|
console
| true |
statement
| 15 | 15 | false | false |
[
"stage_file",
"name",
"stage_file_obj",
"console",
"content",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"source_file",
"tests",
"update_report",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.console.rule(f'[bold green][Process stage] {os.path.basename(self.stage_file).split(".")[0]}:{self.name}',
align='left')
def _show_result(self, error=None):
stage_name = f'{os.path.basename(self.stage_file).split(".")[0]}:{self.name}'
if error is not None:
click.echo(f'Skipped stage [{stage_name}] Error: {error}')
self.console.rule(f'[bold red][Failed] {stage_name}', align='left')
else:
self.
|
1,974 | 41 | 1,149 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
Unknown
|
content
| true |
statement
| 15 | 15 | false | true |
[
"source_file",
"stage_file",
"name",
"console",
"content",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"stage_file_obj",
"tests",
"update_report",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.console.rule(f'[bold green][Process stage] {os.path.basename(self.stage_file).split(".")[0]}:{self.name}',
align='left')
def _show_result(self, error=None):
stage_name = f'{os.path.basename(self.stage_file).split(".")[0]}:{self.name}'
if error is not None:
click.echo(f'Skipped stage [{stage_name}] Error: {error}')
self.console.rule(f'[bold red][Failed] {stage_name}', align='left')
else:
self.console.rule(f'[bold green][Pass] {stage_name}', align='left')
def _load_source(self):
if 'data' not in self.
|
1,975 | 41 | 1,241 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
Unknown
|
content
| true |
statement
| 15 | 15 | false | false |
[
"source_file",
"name",
"stage_file",
"console",
"content",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"stage_file_obj",
"tests",
"update_report",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.console.rule(f'[bold green][Process stage] {os.path.basename(self.stage_file).split(".")[0]}:{self.name}',
align='left')
def _show_result(self, error=None):
stage_name = f'{os.path.basename(self.stage_file).split(".")[0]}:{self.name}'
if error is not None:
click.echo(f'Skipped stage [{stage_name}] Error: {error}')
self.console.rule(f'[bold red][Failed] {stage_name}', align='left')
else:
self.console.rule(f'[bold green][Pass] {stage_name}', align='left')
def _load_source(self):
if 'data' not in self.content:
raise ValueError('data is required field')
source_name = self.
|
1,977 | 41 | 1,347 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
Unknown
|
stage_file
| true |
statement
| 15 | 15 | false | false |
[
"stage_file",
"source_file",
"name",
"content",
"console",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"stage_file_obj",
"tests",
"update_report",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.console.rule(f'[bold green][Process stage] {os.path.basename(self.stage_file).split(".")[0]}:{self.name}',
align='left')
def _show_result(self, error=None):
stage_name = f'{os.path.basename(self.stage_file).split(".")[0]}:{self.name}'
if error is not None:
click.echo(f'Skipped stage [{stage_name}] Error: {error}')
self.console.rule(f'[bold red][Failed] {stage_name}', align='left')
else:
self.console.rule(f'[bold green][Pass] {stage_name}', align='left')
def _load_source(self):
if 'data' not in self.content:
raise ValueError('data is required field')
source_name = self.content['data']
self.source_file = os.path.abspath(
os.path.join(os.path.dirname(self.
|
1,978 | 41 | 1,440 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
Unknown
|
content
| true |
statement
| 15 | 15 | false | false |
[
"stage_file",
"name",
"console",
"content",
"source_file",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"stage_file_obj",
"tests",
"update_report",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.console.rule(f'[bold green][Process stage] {os.path.basename(self.stage_file).split(".")[0]}:{self.name}',
align='left')
def _show_result(self, error=None):
stage_name = f'{os.path.basename(self.stage_file).split(".")[0]}:{self.name}'
if error is not None:
click.echo(f'Skipped stage [{stage_name}] Error: {error}')
self.console.rule(f'[bold red][Failed] {stage_name}', align='left')
else:
self.console.rule(f'[bold green][Pass] {stage_name}', align='left')
def _load_source(self):
if 'data' not in self.content:
raise ValueError('data is required field')
source_name = self.content['data']
self.source_file = os.path.abspath(
os.path.join(os.path.dirname(self.stage_file), '../sources', f'{source_name}.yaml'))
def tests(self):
return self.
|
1,979 | 41 | 1,990 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
infile
|
_show_progress
| true |
function
| 15 | 15 | true | true |
[
"stage_file",
"console",
"name",
"update_report",
"source_file",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"content",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"stage_file_obj",
"tests",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.console.rule(f'[bold green][Process stage] {os.path.basename(self.stage_file).split(".")[0]}:{self.name}',
align='left')
def _show_result(self, error=None):
stage_name = f'{os.path.basename(self.stage_file).split(".")[0]}:{self.name}'
if error is not None:
click.echo(f'Skipped stage [{stage_name}] Error: {error}')
self.console.rule(f'[bold red][Failed] {stage_name}', align='left')
else:
self.console.rule(f'[bold green][Pass] {stage_name}', align='left')
def _load_source(self):
if 'data' not in self.content:
raise ValueError('data is required field')
source_name = self.content['data']
self.source_file = os.path.abspath(
os.path.join(os.path.dirname(self.stage_file), '../sources', f'{source_name}.yaml'))
def tests(self):
return self.content['tests']
def run(self, keep_ge_workspace=False):
from piperider_cli.data import execute_ge_checkpoint
from piperider_cli.ydata.data_expectations import DataExpectationsReporter
from tempfile import TemporaryDirectory
with TemporaryDirectory() as tmp_dir:
ge_workspace = tmp_dir
if keep_ge_workspace:
ge_workspace = os.path.join(os.getcwd(), f'ge_dir_{int(time())}')
click.echo(f'Keep ge workspace at {ge_workspace}')
try:
self.
|
1,980 | 41 | 2,121 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
infile
|
copy_report
| true |
function
| 15 | 15 | false | true |
[
"stage_file",
"source_file",
"update_report",
"stage_file_obj",
"content",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"console",
"copy_report",
"execute_custom_assertions",
"name",
"refine_ydata_result",
"run",
"tests",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.console.rule(f'[bold green][Process stage] {os.path.basename(self.stage_file).split(".")[0]}:{self.name}',
align='left')
def _show_result(self, error=None):
stage_name = f'{os.path.basename(self.stage_file).split(".")[0]}:{self.name}'
if error is not None:
click.echo(f'Skipped stage [{stage_name}] Error: {error}')
self.console.rule(f'[bold red][Failed] {stage_name}', align='left')
else:
self.console.rule(f'[bold green][Pass] {stage_name}', align='left')
def _load_source(self):
if 'data' not in self.content:
raise ValueError('data is required field')
source_name = self.content['data']
self.source_file = os.path.abspath(
os.path.join(os.path.dirname(self.stage_file), '../sources', f'{source_name}.yaml'))
def tests(self):
return self.content['tests']
def run(self, keep_ge_workspace=False):
from piperider_cli.data import execute_ge_checkpoint
from piperider_cli.ydata.data_expectations import DataExpectationsReporter
from tempfile import TemporaryDirectory
with TemporaryDirectory() as tmp_dir:
ge_workspace = tmp_dir
if keep_ge_workspace:
ge_workspace = os.path.join(os.getcwd(), f'ge_dir_{int(time())}')
click.echo(f'Keep ge workspace at {ge_workspace}')
try:
self._show_progress()
all_columns, ge_context = execute_ge_checkpoint(ge_workspace, self)
ge_report_file = self.
|
1,981 | 41 | 2,244 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
infile
|
execute_custom_assertions
| true |
function
| 15 | 15 | false | true |
[
"stage_file",
"console",
"name",
"source_file",
"content",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"stage_file_obj",
"tests",
"update_report",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.console.rule(f'[bold green][Process stage] {os.path.basename(self.stage_file).split(".")[0]}:{self.name}',
align='left')
def _show_result(self, error=None):
stage_name = f'{os.path.basename(self.stage_file).split(".")[0]}:{self.name}'
if error is not None:
click.echo(f'Skipped stage [{stage_name}] Error: {error}')
self.console.rule(f'[bold red][Failed] {stage_name}', align='left')
else:
self.console.rule(f'[bold green][Pass] {stage_name}', align='left')
def _load_source(self):
if 'data' not in self.content:
raise ValueError('data is required field')
source_name = self.content['data']
self.source_file = os.path.abspath(
os.path.join(os.path.dirname(self.stage_file), '../sources', f'{source_name}.yaml'))
def tests(self):
return self.content['tests']
def run(self, keep_ge_workspace=False):
from piperider_cli.data import execute_ge_checkpoint
from piperider_cli.ydata.data_expectations import DataExpectationsReporter
from tempfile import TemporaryDirectory
with TemporaryDirectory() as tmp_dir:
ge_workspace = tmp_dir
if keep_ge_workspace:
ge_workspace = os.path.join(os.getcwd(), f'ge_dir_{int(time())}')
click.echo(f'Keep ge workspace at {ge_workspace}')
try:
self._show_progress()
all_columns, ge_context = execute_ge_checkpoint(ge_workspace, self)
ge_report_file = self.copy_report(ge_workspace)
ydata_report_file = ge_report_file.replace('.json', '_ydata.json')
self.
|
1,982 | 41 | 2,421 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
Unknown
|
source_file
| true |
statement
| 15 | 15 | false | true |
[
"name",
"stage_file",
"console",
"source_file",
"stage_file_obj",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"content",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"tests",
"update_report",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.console.rule(f'[bold green][Process stage] {os.path.basename(self.stage_file).split(".")[0]}:{self.name}',
align='left')
def _show_result(self, error=None):
stage_name = f'{os.path.basename(self.stage_file).split(".")[0]}:{self.name}'
if error is not None:
click.echo(f'Skipped stage [{stage_name}] Error: {error}')
self.console.rule(f'[bold red][Failed] {stage_name}', align='left')
else:
self.console.rule(f'[bold green][Pass] {stage_name}', align='left')
def _load_source(self):
if 'data' not in self.content:
raise ValueError('data is required field')
source_name = self.content['data']
self.source_file = os.path.abspath(
os.path.join(os.path.dirname(self.stage_file), '../sources', f'{source_name}.yaml'))
def tests(self):
return self.content['tests']
def run(self, keep_ge_workspace=False):
from piperider_cli.data import execute_ge_checkpoint
from piperider_cli.ydata.data_expectations import DataExpectationsReporter
from tempfile import TemporaryDirectory
with TemporaryDirectory() as tmp_dir:
ge_workspace = tmp_dir
if keep_ge_workspace:
ge_workspace = os.path.join(os.getcwd(), f'ge_dir_{int(time())}')
click.echo(f'Keep ge workspace at {ge_workspace}')
try:
self._show_progress()
all_columns, ge_context = execute_ge_checkpoint(ge_workspace, self)
ge_report_file = self.copy_report(ge_workspace)
ydata_report_file = ge_report_file.replace('.json', '_ydata.json')
self.execute_custom_assertions(ge_context, ge_report_file)
# generate ydata report
df = pd.DataFrame(columns=all_columns)
datasource_name = self.
|
1,983 | 41 | 2,519 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
inproject
|
evaluate
| true |
function
| 9 | 23 | false | true |
[
"df",
"tests",
"df_type",
"label",
"dtypes",
"evaluate",
"get_warnings",
"random_state",
"store_warning",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__slots__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "df",
"type": "property"
},
{
"name": "df_type",
"type": "property"
},
{
"name": "dtypes",
"type": "property"
},
{
"name": "evaluate",
"type": "function"
},
{
"name": "get_warnings",
"type": "function"
},
{
"name": "label",
"type": "property"
},
{
"name": "random_state",
"type": "property"
},
{
"name": "store_warning",
"type": "function"
},
{
"name": "tests",
"type": "property"
},
{
"name": "_clean_warnings",
"type": "function"
},
{
"name": "_coverage_fraction",
"type": "function"
},
{
"name": "_df",
"type": "statement"
},
{
"name": "_df_type",
"type": "statement"
},
{
"name": "_dtypes",
"type": "statement"
},
{
"name": "_expectation_level_assessment",
"type": "function"
},
{
"name": "_label",
"type": "statement"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "_overall_assessment",
"type": "function"
},
{
"name": "_random_state",
"type": "statement"
},
{
"name": "_report",
"type": "function"
},
{
"name": "_summarize_results",
"type": "function"
},
{
"name": "_tests",
"type": "statement"
},
{
"name": "_warnings",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.console.rule(f'[bold green][Process stage] {os.path.basename(self.stage_file).split(".")[0]}:{self.name}',
align='left')
def _show_result(self, error=None):
stage_name = f'{os.path.basename(self.stage_file).split(".")[0]}:{self.name}'
if error is not None:
click.echo(f'Skipped stage [{stage_name}] Error: {error}')
self.console.rule(f'[bold red][Failed] {stage_name}', align='left')
else:
self.console.rule(f'[bold green][Pass] {stage_name}', align='left')
def _load_source(self):
if 'data' not in self.content:
raise ValueError('data is required field')
source_name = self.content['data']
self.source_file = os.path.abspath(
os.path.join(os.path.dirname(self.stage_file), '../sources', f'{source_name}.yaml'))
def tests(self):
return self.content['tests']
def run(self, keep_ge_workspace=False):
from piperider_cli.data import execute_ge_checkpoint
from piperider_cli.ydata.data_expectations import DataExpectationsReporter
from tempfile import TemporaryDirectory
with TemporaryDirectory() as tmp_dir:
ge_workspace = tmp_dir
if keep_ge_workspace:
ge_workspace = os.path.join(os.getcwd(), f'ge_dir_{int(time())}')
click.echo(f'Keep ge workspace at {ge_workspace}')
try:
self._show_progress()
all_columns, ge_context = execute_ge_checkpoint(ge_workspace, self)
ge_report_file = self.copy_report(ge_workspace)
ydata_report_file = ge_report_file.replace('.json', '_ydata.json')
self.execute_custom_assertions(ge_context, ge_report_file)
# generate ydata report
df = pd.DataFrame(columns=all_columns)
datasource_name = self.source_file.split('/')[-1]
der = DataExpectationsReporter()
results = der.
|
1,984 | 41 | 2,909 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
Unknown
|
console
| true |
statement
| 15 | 15 | false | false |
[
"stage_file",
"name",
"source_file",
"stage_file_obj",
"console",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"content",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"tests",
"update_report",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.console.rule(f'[bold green][Process stage] {os.path.basename(self.stage_file).split(".")[0]}:{self.name}',
align='left')
def _show_result(self, error=None):
stage_name = f'{os.path.basename(self.stage_file).split(".")[0]}:{self.name}'
if error is not None:
click.echo(f'Skipped stage [{stage_name}] Error: {error}')
self.console.rule(f'[bold red][Failed] {stage_name}', align='left')
else:
self.console.rule(f'[bold green][Pass] {stage_name}', align='left')
def _load_source(self):
if 'data' not in self.content:
raise ValueError('data is required field')
source_name = self.content['data']
self.source_file = os.path.abspath(
os.path.join(os.path.dirname(self.stage_file), '../sources', f'{source_name}.yaml'))
def tests(self):
return self.content['tests']
def run(self, keep_ge_workspace=False):
from piperider_cli.data import execute_ge_checkpoint
from piperider_cli.ydata.data_expectations import DataExpectationsReporter
from tempfile import TemporaryDirectory
with TemporaryDirectory() as tmp_dir:
ge_workspace = tmp_dir
if keep_ge_workspace:
ge_workspace = os.path.join(os.getcwd(), f'ge_dir_{int(time())}')
click.echo(f'Keep ge workspace at {ge_workspace}')
try:
self._show_progress()
all_columns, ge_context = execute_ge_checkpoint(ge_workspace, self)
ge_report_file = self.copy_report(ge_workspace)
ydata_report_file = ge_report_file.replace('.json', '_ydata.json')
self.execute_custom_assertions(ge_context, ge_report_file)
# generate ydata report
df = pd.DataFrame(columns=all_columns)
datasource_name = self.source_file.split('/')[-1]
der = DataExpectationsReporter()
results = der.evaluate(ge_report_file, df)
expectations_report, expectations_dense = results['Expectation Level Assessment']
markdown_template = f'''
# Status
* Data Source : {datasource_name}
* Data Columns : {all_columns}
* Output Reports
* Test report: {ge_report_file}
* Ydata report: {ydata_report_file}
# Output
``` text
{expectations_report}
```
'''
self.
|
1,985 | 41 | 3,069 |
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
infile
|
refine_ydata_result
| true |
function
| 15 | 15 | false | true |
[
"stage_file",
"source_file",
"content",
"name",
"copy_report",
"__init__",
"_load_source",
"_show_progress",
"_show_result",
"console",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"stage_file_obj",
"tests",
"update_report",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "console",
"type": "statement"
},
{
"name": "content",
"type": "statement"
},
{
"name": "copy_report",
"type": "function"
},
{
"name": "execute_custom_assertions",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "refine_ydata_result",
"type": "function"
},
{
"name": "run",
"type": "function"
},
{
"name": "source_file",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_file_obj",
"type": "statement"
},
{
"name": "tests",
"type": "function"
},
{
"name": "update_report",
"type": "function"
},
{
"name": "_load_source",
"type": "function"
},
{
"name": "_show_progress",
"type": "function"
},
{
"name": "_show_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import os
import shutil
from glob import glob
from time import time
import click
import pandas as pd
from rich.console import Console
from rich.markdown import Markdown
class Stage(object):
def __init__(self, stage_file, name, content):
self.stage_file_obj = stage_file
self.stage_file = stage_file.stage_file
self.name = name
self.content = content
self.source_file = None
self.console = Console()
self._load_source()
def _show_progress(self):
self.console.rule(f'[bold green][Process stage] {os.path.basename(self.stage_file).split(".")[0]}:{self.name}',
align='left')
def _show_result(self, error=None):
stage_name = f'{os.path.basename(self.stage_file).split(".")[0]}:{self.name}'
if error is not None:
click.echo(f'Skipped stage [{stage_name}] Error: {error}')
self.console.rule(f'[bold red][Failed] {stage_name}', align='left')
else:
self.console.rule(f'[bold green][Pass] {stage_name}', align='left')
def _load_source(self):
if 'data' not in self.content:
raise ValueError('data is required field')
source_name = self.content['data']
self.source_file = os.path.abspath(
os.path.join(os.path.dirname(self.stage_file), '../sources', f'{source_name}.yaml'))
def tests(self):
return self.content['tests']
def run(self, keep_ge_workspace=False):
from piperider_cli.data import execute_ge_checkpoint
from piperider_cli.ydata.data_expectations import DataExpectationsReporter
from tempfile import TemporaryDirectory
with TemporaryDirectory() as tmp_dir:
ge_workspace = tmp_dir
if keep_ge_workspace:
ge_workspace = os.path.join(os.getcwd(), f'ge_dir_{int(time())}')
click.echo(f'Keep ge workspace at {ge_workspace}')
try:
self._show_progress()
all_columns, ge_context = execute_ge_checkpoint(ge_workspace, self)
ge_report_file = self.copy_report(ge_workspace)
ydata_report_file = ge_report_file.replace('.json', '_ydata.json')
self.execute_custom_assertions(ge_context, ge_report_file)
# generate ydata report
df = pd.DataFrame(columns=all_columns)
datasource_name = self.source_file.split('/')[-1]
der = DataExpectationsReporter()
results = der.evaluate(ge_report_file, df)
expectations_report, expectations_dense = results['Expectation Level Assessment']
markdown_template = f'''
# Status
* Data Source : {datasource_name}
* Data Columns : {all_columns}
* Output Reports
* Test report: {ge_report_file}
* Ydata report: {ydata_report_file}
# Output
``` text
{expectations_report}
```
'''
self.console.print(Markdown(markdown_template))
# save ydata report
with open(ydata_report_file, 'w') as fh:
outputs = self.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.