idx
int64 2
7.85k
| idx_lca
int64 0
223
| offset
int64 165
54.4k
| repo
stringclasses 54
values | commit_hash
stringclasses 100
values | target_file
stringclasses 118
values | line_type_lca
stringclasses 6
values | ground_truth
stringlengths 1
40
| in_completions
bool 1
class | completion_type
stringclasses 6
values | non_dunder_count_intellij
int64 1
127
| non_dunder_count_jedi
int64 1
128
| start_with_
bool 1
class | first_occurrence
bool 2
classes | intellij_completions
listlengths 1
149
| jedi_completions
listlengths 3
148
| prefix
stringlengths 165
54.4k
| intellij_completions_filtered
listlengths 1
123
| prefix_truncated
stringlengths 165
1.92k
| __index_level_0__
int64 1
5.53k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1,385
| 36
| 36,789
|
cray-hpe__docs-csm
|
3aeddea9f5df21148c84af36f97fed541a4ab1f5
|
scripts/operations/node_management/Add_Remove_Replace_NCNs/remove_management_ncn.py
|
infile
|
xname
| true
|
statement
| 17
| 17
| false
| false
|
[
"xname",
"ncn_name",
"parent",
"run_ipmitool",
"ipmi_username",
"__init__",
"aliases",
"bmc_mac",
"directory",
"hsm_macs",
"ifnames",
"ip_reservation_aliases",
"ip_reservation_ips",
"ipmi_password",
"remove_ips",
"save",
"verbose",
"workers",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "aliases",
"type": "statement"
},
{
"name": "bmc_mac",
"type": "statement"
},
{
"name": "directory",
"type": "statement"
},
{
"name": "hsm_macs",
"type": "statement"
},
{
"name": "ifnames",
"type": "statement"
},
{
"name": "ip_reservation_aliases",
"type": "statement"
},
{
"name": "ip_reservation_ips",
"type": "statement"
},
{
"name": "ipmi_password",
"type": "statement"
},
{
"name": "ipmi_username",
"type": "statement"
},
{
"name": "ncn_name",
"type": "statement"
},
{
"name": "parent",
"type": "statement"
},
{
"name": "remove_ips",
"type": "statement"
},
{
"name": "run_ipmitool",
"type": "statement"
},
{
"name": "save",
"type": "function"
},
{
"name": "verbose",
"type": "statement"
},
{
"name": "workers",
"type": "statement"
},
{
"name": "xname",
"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"
}
] |
#!/usr/bin/env python3
# MIT License
#
# (C) Copyright [2022] Hewlett Packard Enterprise Development LP
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.
import argparse
import http
import json
import logging
import os
import pathlib
import re
import requests
import shutil
import subprocess
import sys
import urllib3
BASE_URL = ''
BSS_URL = ''
HSM_URL = ''
SLS_URL = ''
KEA_URL = ''
# This is the list of NCNs for which the IPs should not be removed from /etc/hosts
NCN_DO_NOT_REMOVE_IPS = [
'ncn-m001', 'ncn-m002', 'ncn-m003',
'ncn-w001', 'ncn-w002', 'ncn-w003',
'ncn-s001', 'ncn-s002', 'ncn-s003',
]
class Logger:
def __init__(self):
self.log_file = None
def init_logger(self, log_file, verbose=False):
self.log_file = log_file
if log_file:
if verbose:
logging.basicConfig(filename=log_file, filemode='w', level=logging.DEBUG,
format='%(levelname)s: %(message)s')
else:
logging.basicConfig(filename=log_file, filemode='w', level=logging.INFO,
format='%(levelname)s: %(message)s')
# the encoding argument is not in python 3.6.15
# logging.basicConfig(filename=log_file, filemode='w', level=logging.INFO, encoding='utf-8',
# format='%(levelname)s: %(message)s')
def info(self, message):
print(message)
if self.log_file:
logging.info(message)
def warning(self, message):
print(f'Warning: {message}')
if self.log_file:
logging.warning(message)
def error(self, message):
print(f'Error: {message}')
if self.log_file:
logging.error(message)
log = Logger()
class State:
def __init__(self, xname=None, directory=None, dry_run=False, verbose=False):
self.xname = xname
self.parent = None
self.ncn_name = ""
self.aliases = set()
self.ip_reservation_aliases = set()
self.ip_reservation_ips = set()
self.hsm_macs = set()
self.workers = set()
self.remove_ips = True
self.ifnames = []
self.bmc_mac = None
self.verbose = verbose
self.ipmi_username = None
self.ipmi_password = None
self.run_ipmitool = False
if directory and xname:
self.directory = os.path.join(directory, xname)
else:
self.directory = directory
if self.directory:
# todo possibly add check that prevents saved files from being overwritten
# file_list = os.listdir(self.directory)
# if 'dry-run' in file_list:
# # continue because the previous run was a dry-run
# pass
# elif len(os.listdir(self.directory)) != 0:
# print(f'Error: Save directory is not empty: {self.directory}. Use --force option to over write it.')
# sys.exit(1)
dry_run_flag_file = os.path.join(self.directory, 'dry-run')
# remove directory if previous run was a dry run
if os.path.exists(dry_run_flag_file):
shutil.rmtree(self.directory)
# create the directory
if not os.path.exists(self.directory):
os.makedirs(self.directory)
if dry_run:
pathlib.Path(dry_run_flag_file).touch()
else:
if os.path.exists(dry_run_flag_file):
os.remove(dry_run_flag_file)
def save(self, name, data):
if self.directory:
file = os.path.join(self.directory, f'{name}.json')
with open(file, 'w', encoding='utf-8') as f:
json.dump(data, f, ensure_ascii=False, indent=2)
class CommandAction:
def __init__(self, command, verbose=False):
self.command = command
self.has_run = False
self.return_code = -1
self.stdout = None
self.stderr = None
self.verbose = verbose
class HttpAction:
def __init__(self, method, url, logs=None, request_body="", response_body="", completed=False, success=False):
self.method = method
self.url = url
self.logs = [] if logs is None else logs
self.request_body = request_body
self.response_body = response_body
self.completed = completed
self.success = success
self.response = None
def log(self, message):
self.logs.append(message)
def get_response_body(self, default_value=None):
if default_value is None:
return self.response_body
if self.response_body:
return self.response_body
return default_value
def setup_urls(args):
global BASE_URL
global BSS_URL
global HSM_URL
global SLS_URL
global KEA_URL
if args.base_url:
BASE_URL = args.base_url
else:
BASE_URL = 'https://api-gw-service-nmn.local/apis'
if args.bss_url:
BSS_URL = args.bss_url
elif args.test_urls:
BSS_URL = 'http://localhost:27778/boot/v1'
else:
BSS_URL = f'{BASE_URL}/bss/boot/v1'
if args.hsm_url:
HSM_URL = args.hsm_url
elif args.test_urls:
HSM_URL = 'http://localhost:27779/hsm/v2'
else:
HSM_URL = f'{BASE_URL}/smd/hsm/v2'
if args.sls_url:
SLS_URL = args.sls_url
elif args.test_urls:
SLS_URL = 'http://localhost:8376/v1'
else:
SLS_URL = f'{BASE_URL}/sls/v1'
KEA_URL = f'{BASE_URL}/dhcp-kea'
def print_urls():
log.info(f'BSS_URL: {BSS_URL}')
log.info(f'HSM_URL: {HSM_URL}')
log.info(f'SLS_URL: {SLS_URL}')
log.info(f'KEA_URL: {KEA_URL}')
def print_summary(state):
log.info('Summary:')
log.info(f' Logs: {state.directory}')
log.info(f' xname: {state.xname}')
log.info(f' ncn_name: {state.ncn_name}')
log.info(f' ncn_macs:')
log.info(f' ifnames: {", ".join(state.ifnames)}')
log.info(f' bmc_mac: {state.bmc_mac if state.bmc_mac else "Unknown"}')
def print_action(action):
if action.completed:
if action.success:
log.info(f"Called: {action.method.upper()} {action.url}")
else:
log.error(f"Failed: {action.method.upper()} {action.url}")
log.info(json.dumps(action.response_body, indent=2))
else:
log.info(f"Planned: {action.method.upper()} {action.url}")
for a_log in action.logs:
log.info(' ' + a_log)
def print_actions(actions):
for action in actions:
print_action(action)
def print_command_action(action):
if action.has_run:
log.info(f'Ran: {" ".join(action.command)}')
if action.return_code != 0:
log.error(f' Failed: {action.return_code}')
log.info(f' stdout:\n{action.stdout}')
log.info(f' stderr:\n{action.stderr}')
elif action.verbose:
log.info(f' stdout:\n{action.stdout}')
if action.stderr:
log.info(f' stderr:\n{action.stderr}')
else:
log.info(f'Planned: {" ".join(action.command)}')
def print_command_actions(actions):
for action in actions:
print_command_action(action)
def http_get(session, actions, url, exit_on_error=True):
r = session.get(url)
action = HttpAction('get', url, response_body=r.text, completed=True)
actions.append(action)
action.response = r
if r.status_code == http.HTTPStatus.OK:
action.success = True
elif exit_on_error:
log_error_and_exit(actions, str(action))
return action
def log_error_and_exit(actions, message):
print_actions(actions)
log.error(f'{message}')
sys.exit(1)
def node_bmc_to_enclosure(xname_for_bmc):
p = re.compile('^(x[0-9]{1,4}c0s[0-9]+)(b)([0-9]+)$')
if p.match(xname_for_bmc):
# convert node bmc to enclosure, for example, convert x3000c0s36b0 to x3000c0s36e0
enclosure = re.sub(p, r'\1e\3', xname_for_bmc)
return enclosure
return None
def add_delete_action_if_component_present(actions, state, session, url, save_file):
action = http_get(session, actions, url, exit_on_error=False)
if action.success:
state.save(save_file, json.loads(action.response_body))
actions.append(HttpAction('delete', url))
not_found = action.response.status_code == http.HTTPStatus.NOT_FOUND
if not_found:
action.success = True
action.log('The item does not need to be deleted, because it does not exist.')
def validate_ipmi_config(state):
if state.run_ipmitool:
if not state.ipmi_password:
log.error('IPMI_PASSWORD not set')
log.error('The environment variable IPMI_PASSWORD is required')
log.error('It should be set to the password of the BMC that is being removed')
sys.exit(1)
if not state.ipmi_username:
log.error('IPMI_USERNAME not set')
log.error('The environment variable IPMI_USERNAME is required')
log.error('It should be set to the username of the BMC that is being removed')
sys.exit(1)
def create_sls_actions(session, state):
actions = []
hardware_action = http_get(session, actions, f'{SLS_URL}/hardware')
networks_action = http_get(session, actions, f'{SLS_URL}/networks')
# Find xname in hardware and get aliases
found_hardware_for_xname = False
hardware_list = json.loads(hardware_action.response_body)
for hardware in hardware_list:
extra_properties = hardware.get('ExtraProperties', {})
if state.xname == hardware['Xname']:
type_string = hardware.get('TypeString')
role = extra_properties.get('Role')
sub_role = extra_properties.get('SubRole')
if type_string != 'Node' or role != 'Management' or sub_role not in ['Worker', 'Storage', 'Master']:
log_error_and_exit(
actions,
f'{state.xname} is Type: {type_string}, Role: {role}, SubRole: {sub_role}. ' +
'The node must be Type: Node, Role: Management, SubRole: one of Worker, Storage, or Master.')
found_hardware_for_xname = True
state.save(f'sls-hardware-{state.xname}', hardware)
state.parent = hardware.get('Parent')
hardware_action.log(
f'Found Hardware: Xname: {state.xname}, ' +
f'Parent: {state.parent}, ' +
f'TypeString: {hardware["TypeString"]}, ' +
f'Role: {hardware.get("ExtraProperties").get("Role")}')
state.aliases.update(extra_properties.get('Aliases', []))
hardware_action.log(f'Aliases: {state.aliases}')
alias_count = len(state.aliases)
if alias_count != 1:
log.warning(f'Expected to find only one alias. Instead found {state.aliases}')
if alias_count > 0:
state.ncn_name = list(state.aliases)[0]
log.info(f'xname: {state.xname}')
log.info(f'ncn name: {state.ncn_name}')
if state.ncn_name in NCN_DO_NOT_REMOVE_IPS:
state.remove_ips = False
# Requires that the parent is known.
# The loop through the hardware_list above finds the given node and parent
# That is why this must loop through the hardware list again after the loop above.
hardware_connectors = []
for hardware in hardware_list:
extra_properties = hardware.get('ExtraProperties', {})
# Check for nic connections
for nic in extra_properties.get("NodeNics", []):
if nic == state.parent:
hardware_connectors.append(hardware.get('Xname'))
state.save(f'sls-hardware-{hardware.get("Xname")}', hardware)
hardware_action.log(f'Found Connector Hardware: Xname: {hardware.get("Xname")}, NodeNic: {nic}')
type_string = hardware.get('TypeString')
role = extra_properties.get('Role')
sub_role = extra_properties.get('SubRole')
if type_string == 'Node' and role == 'Management' and sub_role in ['Worker', 'Storage', 'Master']:
aliases = extra_properties.get('Aliases', [])
for alias in aliases:
if alias not in state.aliases:
state.workers.add(alias)
for connector in hardware_connectors:
actions.append(HttpAction('delete', f'{SLS_URL}/hardware/{connector}'))
if found_hardware_for_xname:
actions.append(HttpAction('delete', f'{SLS_URL}/hardware/{state.xname}'))
state.save('sls-hardware', hardware_list)
else:
log_error_and_exit(actions, f'Failed to find sls hardware entry for xname: {state.xname}')
# Find network references for the aliases and the parent
networks = json.loads(networks_action.response_body)
state.save('sls-networks', networks)
for network in networks:
network_name = network.get("Name")
if network_name == 'HSN':
# Skip the HSN network. This network is owned by slingshot.
continue
logs = []
network_has_changes = False
extra_properties = network.get('ExtraProperties')
subnets = extra_properties['Subnets']
if subnets is None:
continue
for subnet in subnets:
ip_reservations = subnet.get('IPReservations')
if ip_reservations is None:
continue
new_ip_reservations = []
subnet_has_changes = False
for ip_reservation in ip_reservations:
rname = ip_reservation['Name']
if rname not in state.aliases and rname != state.parent and rname != state.xname:
new_ip_reservations.append(ip_reservation)
else:
subnet_has_changes = True
a = ip_reservation.get('Aliases')
if a:
state.ip_reservation_aliases.update(ip_reservation.get('Aliases'))
state.ip_reservation_aliases.add(ip_reservation.get('Name'))
state.ip_reservation_ips.add(ip_reservation.get('IPAddress'))
if state.remove_ips:
logs.append(
f'Removed IP Reservation in {network["Name"]} ' +
f'in subnet {subnet["Name"]} for {ip_reservation["Name"]}')
logs.append(
'IP Reservation Details: ' +
f'Name: {ip_reservation.get("Name")}, ' +
f'IPAddress: {ip_reservation.get("IPAddress")}, ' +
f'Aliases: {ip_reservation.get("Aliases")}')
state.save(f'sls-ip-reservation-{network["Name"]}-{subnet["Name"]}-{ip_reservation["Name"]}',
ip_reservation)
if state.remove_ips and subnet_has_changes:
network_has_changes = True
subnet['IPReservations'] = new_ip_reservations
if state.remove_ips and network_has_changes:
request_body = json.dumps(network)
action = HttpAction(
'put', f'{SLS_URL}/networks/{network["Name"]}', logs=logs, request_body=request_body)
actions.append(action)
return actions
def create_hsm_actions(session, state):
actions = []
# xname ethernet interfaces
ethernet_xname_action = http_get(session, actions,
f'{HSM_URL}/Inventory/EthernetInterfaces?ComponentId={state.xname}')
ethernet_list = json.loads(ethernet_xname_action.response_body)
for ethernet in ethernet_list:
ethernet_id = ethernet.get('ID')
actions.append(HttpAction('delete', f'{HSM_URL}/Inventory/EthernetInterfaces/{ethernet_id}'))
state.save(f'hsm-ethernet-interface-{ethernet_id}', ethernet)
mac = ethernet.get('MACAddress')
if mac:
state.hsm_macs.add(mac)
# bmc (parent) ethernet interfaces
ethernet_parent_action = http_get(session, actions,
f'{HSM_URL}/Inventory/EthernetInterfaces?ComponentId={state.parent}')
ethernet_list = json.loads(ethernet_parent_action.response_body)
for ethernet in ethernet_list:
ethernet_id = ethernet.get('ID')
actions.append(HttpAction('delete', f'{HSM_URL}/Inventory/EthernetInterfaces/{ethernet_id}'))
state.save(f'hsm-ethernet-interface-{ethernet_id}', ethernet)
mac = ethernet.get('MACAddress')
if mac:
state.hsm_macs.add(mac)
# delete parent redfish endpoints
add_delete_action_if_component_present(
actions, state, session, f'{HSM_URL}/Inventory/RedfishEndpoints/{state.parent}', f'hsm-redfish-endpoints-{state.parent}')
# delete xname from component state
add_delete_action_if_component_present(
actions, state, session, f'{HSM_URL}/State/Components/{state.xname}', f'hsm-component-{state.xname}')
# delete parent from component state
add_delete_action_if_component_present(
actions, state, session, f'{HSM_URL}/State/Components/{state.parent}', f'hsm-component-{state.parent}')
# delete node enclosure for parent from component state
node_enclosure_xname = node_bmc_to_enclosure(state.parent)
if node_enclosure_xname:
add_delete_action_if_component_present(
actions, state, session, f'{HSM_URL}/State/Components/{node_enclosure_xname}', f'hsm-component-{node_enclosure_xname}')
else:
log.error(f'failed to create enclosure xname for parent {state.parent}')
return actions
def bss_params_to_ifnames(params):
result = []
arg_list = params.split(' ')
for arg in arg_list:
if arg.startswith('ifname='):
key_value = arg.split('=', 2)
result.append(key_value[1])
return result
def create_bss_actions(session, state):
actions = []
global_bp_action = http_get(session, actions, f'{BSS_URL}/bootparameters?name=Global')
global_bp = json.loads(global_bp_action.response_body)
if len(global_bp) == 0:
log_error_and_exit(actions, "Failed to find Global bootparameters")
elif len(global_bp) > 1:
log.error("unexpectedly found more than one Global bootparameters. Continuing with the only the first entry")
boot_parameter = global_bp[0]
state.save('bss-bootparameters-global', boot_parameter)
# check that ncn being removed is not first master
first_master = boot_parameter.get('cloud-init', {}).get('meta-data', {}).get('first-master-hostname')
if first_master == state.ncn_name:
log_error_and_exit(actions,
'Cannot remove the first master. ' +
f'xname: {state.xname}, ncn-name: {state.ncn_name}, first-master-hostname: {first_master}')
else:
global_bp_action.log(f'first-master-hostname: {first_master}')
# remove host records from Global boot parameters
if state.remove_ips:
host_records = boot_parameter.get('cloud-init').get('meta-data').get('host_records')
new_host_records = []
has_changes = False
for host_record in host_records:
found_alias_match = False
for alias in host_record.get('aliases'):
for alias_prefix in state.aliases:
if alias.startswith(alias_prefix):
found_alias_match = True
if found_alias_match:
has_changes = True
else:
new_host_records.append(host_record)
if has_changes:
boot_parameter.get('cloud-init').get('meta-data')['host_records'] = new_host_records
global_request_body = json.dumps(boot_parameter)
state.save('new-bss-bootparameters-global', boot_parameter)
actions.append(HttpAction('put', f'{BSS_URL}/bootparameters', request_body=global_request_body))
# remove boot parameters for xname
xname_bp_action = http_get(session, actions, f'{BSS_URL}/bootparameters?name={state.xname}')
if xname_bp_action.success:
xname_bp_list = json.loads(xname_bp_action.response_body)
xname_bp = xname_bp_list[0] if len(xname_bp_list) > 0 else {}
state.save(f'bss-bootparameters-{state.xname}', xname_bp_list)
# create delete action
delete_request_body = '{ "hosts" : [ "' + state.xname + '" ] }'
xname_bp_delete_action = HttpAction('delete', f'{BSS_URL}/bootparameters', request_body=delete_request_body)
xname_bp_delete_action.log(delete_request_body)
actions.append(xname_bp_delete_action)
# save interfaces from params
params = xname_bp.get('params')
if params:
state.ifnames = bss_params_to_ifnames(params)
return actions
def create_kea_actions(session, state):
actions = []
for mac in sorted(state.hsm_macs):
request_body = '{"command": "lease4-get-by-hw-address", "service": [ "dhcp4" ], "arguments": {"hw-address": "' + mac + '"}}'
action = HttpAction('post', f'{KEA_URL}', request_body=request_body)
actions.append(action)
action.log(f'Request body: {request_body}')
run_action(session, action)
if state.verbose:
action.log(f'Response body: {action.response_body}')
if action.success:
response = action.get_response_body('[]')
response_json = json.loads(response)
for r in response_json:
leases = r.get("arguments", {}).get("leases", [])
for lease in leases:
ip = lease.get('ip-address')
if ip:
if ip not in state.ip_reservation_ips:
state.ip_reservation_ips.add(ip)
action.log(f'Added {ip} to the list of kea leases to remove')
for ip in sorted(state.ip_reservation_ips):
request_body = '{"command": "lease4-del", "service": [ "dhcp4" ], "arguments": {"ip-address": "' + ip + '"}}'
action = HttpAction('post', f'{KEA_URL}', request_body=request_body)
actions.append(action)
action.log(f'Request body: {request_body}')
return actions
def run_command(command):
cmd = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
result = cmd.communicate()
stdout = None if not result[0] else result[0].decode('utf-8')
stderr = None if not result[1] else result[1].decode('utf-8')
return cmd.returncode, stdout, stderr
def run_command_action(command):
command.return_code, command.stdout, command.stderr = run_command(command.command)
command.has_run = True
def run_command_actions(command_actions):
for command in command_actions:
if command.has_run:
pass
else:
run_command_action(command)
print_command_action(command)
def check_for_running_pods_on_ncn(state):
for alias in state.aliases:
command_wide = ['kubectl', 'get', 'pods', '--all-namespaces', '--field-selector', f'spec.nodeName={alias}', '-o', 'wide']
command = ['kubectl', 'get', 'pods', '--all-namespaces', '--field-selector', f'spec.nodeName={alias}', '-o', 'json']
return_code, stdout, stderr = run_command(command)
log.info("Ran: " + ' '.join(command))
if return_code != 0:
log.error('kubectl command failed')
log.info(f'Return code: {return_code}')
log.info(f'Standard out:\n{stdout}')
log.info(f'Standard err:\n{stderr}')
sys.exit(1)
if stdout:
response = json.loads(stdout)
items = response.get('items')
if items is not None:
if len(items) != 0:
log.info(' '.join(command_wide))
_, wide_stdout, wide_stderr = run_command(command_wide)
log.info(wide_stdout)
if wide_stderr:
log.info(wide_stderr)
log.error(f'there are pods on {alias}.')
sys.exit(1)
else:
print(
f'Warning: Could not determine if {alias} is running services. Command did not return the expected json')
else:
print(f'Warning: Could not determine if {alias} is running services. Command returned no output.')
def create_restart_bss_restart_actions():
return [
CommandAction(['kubectl', '-n', 'services', 'rollout', 'restart', 'deployment', 'cray-bss']),
]
def create_restart_bss_wait_actions():
return [
CommandAction(['kubectl', '-n', 'services', 'rollout', 'status', 'deployment', 'cray-bss', '--timeout=600s']),
]
def create_update_etc_hosts_actions(state):
command_actions = []
if state.remove_ips:
sorted_workers = sorted(state.workers)
for worker in sorted_workers:
scp_action = CommandAction(['scp', f'{worker}:/etc/hosts', f'{state.directory}/etc-hosts-{worker}'])
command_actions.append(scp_action)
hosts = ','.join(sorted_workers)
cp_backup_action = CommandAction(['pdsh', '-w', hosts,
'cp', '/etc/hosts', f'/tmp/hosts.backup.{state.xname}.{state.ncn_name}'])
command_actions.append(cp_backup_action)
for ip in sorted(state.ip_reservation_ips):
sed_action = CommandAction(['pdsh', '-w', hosts,
'sed', '-i', f'/^{ip}[[:blank:]]/d', f'/etc/hosts'])
command_actions.append(sed_action)
else:
print('Leaving /etc/hosts unchanged')
return command_actions
def create_ipmitool_set_bmc_to_dhcp_actions(state):
command_actions = []
if not state.run_ipmitool:
return command_actions
if not state.ncn_name or not state.ipmi_password or not state.ipmi_username:
# hitting this case is a programming error.
# these values should have been checked by calling validate_ipmi_config(state)
log.error('Unexpected state. Missing one of these values: ncn_name: ' +
f'"{state.ncn_name}", ipmi_username: "{state.ipmi_username}", ipmi_password: "****"')
return command_actions
mc_info_action = CommandAction([
'ipmitool', '-I', 'lanplus', '-U', state.ipmi_username, '-E', '-H', f'{state.ncn_name}-mgmt',
'mc', 'info'],
verbose=state.verbose)
command_actions.append(mc_info_action)
run_command_action(mc_info_action)
lan = '1'
if mc_info_action.stdout:
manufacturer_lines = [line for line in mc_info_action.stdout.split('\n') if 'manufacturer name' in line.lower()]
for line in manufacturer_lines:
if 'intel' in line.lower():
lan = '3'
# Set the BMC to DHCP
change_dhcp_action = CommandAction([
'ipmitool', '-I', 'lanplus', '-U', state.ipmi_username, '-E', '-H', f'{state.ncn_name}-mgmt',
'lan', 'set', lan, "ipsrc", "dhcp"],
verbose=state.verbose)
command_actions.append(change_dhcp_action)
# Restart BMC
restart_bmc_action = CommandAction([
'ipmitool', '-I', 'lanplus', '-U', state.ipmi_username, '-E', '-H', f'{state.ncn_name}-mgmt',
'mc', 'reset', "cold"],
verbose=state.verbose)
command_actions.append(restart_bmc_action)
return command_actions
def create_ipmitool_bmc_mac_actions(state):
command_actions = []
if not state.run_ipmitool:
return command_actions
if not state.ncn_name or not state.ipmi_password or not state.ipmi_username:
# hitting this case is a programming error.
# these values should have been checked by calling validate_ipmi_config(state)
log.error('Unexpected state. Missing one of these values: ncn_name: ' +
f'"{state.ncn_name}", ipmi_username: "{state.ipmi_username}", ipmi_password: "****"')
return command_actions
mc_info_action = CommandAction([
'ipmitool', '-I', 'lanplus', '-U', state.ipmi_username, '-E', '-H', f'{state.ncn_name}-mgmt',
'mc', 'info'],
verbose=state.verbose)
command_actions.append(mc_info_action)
run_command_action(mc_info_action)
lan = '1'
if mc_info_action.stdout:
manufacturer_lines = [line for line in mc_info_action.stdout.split('\n') if 'manufacturer name' in line.lower()]
for line in manufacturer_lines:
if 'intel' in line.lower():
lan = '3'
mac_action = CommandAction([
'ipmitool', '-I', 'lanplus', '-U', state.ipmi_username, '-E', '-H', f'{state.ncn_name}-mgmt',
'lan', 'print', lan],
verbose=state.verbose)
command_actions.append(mac_action)
run_command_action(mac_action)
if mac_action.return_code == 0 and mac_action.stdout:
mac_lines = [line for line in mac_action.stdout.split('\n') if 'mac address' in line.lower()]
for line in mac_lines:
key_value = line.split(':', 1)
if len(key_value) == 2:
state.bmc_mac = key_value[1].strip()
return command_actions
def is_2xx(http_status):
return http_status // 200 == 1
def run_action(session, action):
method = action.method
url = action.url
r = None
if method == 'get':
r = session.get(url)
elif method == 'delete':
r = session.delete(url, data=action.request_body)
elif method == 'put':
r = session.put(url, action.request_body)
elif method == 'post':
r = session.post(url, action.request_body)
else:
print(f"Unknown method {method}")
print("FAILED")
sys.exit(1)
if r:
action.response_body = r.text
action.completed = True
action.success = is_2xx(r.status_code)
def run_actions(session, actions):
for action in actions:
if action.completed:
print_action(action)
else:
run_action(session, action)
print_action(action)
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument('--xname', help='The xname of the ncn to remove', required=True)
parser.add_argument('--dry-run', action='store_true', help='Do a dry run where nothing is modified')
parser.add_argument('--log-dir', '-l', default='/tmp/remove_management_ncn',
help='Directory where to log and save current state.')
parser.add_argument("-v", action="store_true", help="Print verbose output")
# hidden arguments used for testing
parser.add_argument('--base-url', help=argparse.SUPPRESS) # Base url.
parser.add_argument('--sls-url', help=argparse.SUPPRESS) # Base url for sls. Overrides --base-url
parser.add_argument('--hsm-url', help=argparse.SUPPRESS) # Base url for hsm. Overrides --base-url
parser.add_argument('--bss-url', help=argparse.SUPPRESS) # Base url for bss. Overrides --base-url
parser.add_argument('-t', '--test-urls', action='store_true', help=argparse.SUPPRESS) # Use test urls
parser.add_argument('--skip-kea', action='store_true', help=argparse.SUPPRESS) # skip kea actions
parser.add_argument('--skip-etc-hosts', action='store_true', help=argparse.SUPPRESS) # skip /etc/hosts actions
parser.add_argument('--force', action='store_true', help=argparse.SUPPRESS) # skip asking 'are you sure' question
args = parser.parse_args()
state = State(xname=args.xname, directory=args.log_dir, dry_run=args.dry_run, verbose=args.v)
log.init_logger(os.path.join(state.directory, 'log'), verbose=state.verbose)
setup_urls(args)
print_urls()
with requests.Session() as session:
session.verify = False
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
token = os.environ.get('TOKEN')
if token is not None:
session.headers.update({'Authorization': f'Bearer {token}'})
elif not args.test_urls and token is None:
log.error('The TOKEN environment variable is not set.')
log.info('Run the following to set the TOKEN:')
log.info('''export TOKEN=$(curl -s -S -d grant_type=client_credentials \\
-d client_id=admin-client -d client_secret=`kubectl get secrets admin-client-auth \\
-o jsonpath='{.data.client-secret}' | base64 -d` \\
https://api-gw-service-nmn.local/keycloak/realms/shasta/protocol/openid-connect/token \\
| jq -r '.access_token')
''')
sys.exit(1)
session.headers.update({'Content-Type': 'application/json'})
state.ipmi_password = os.environ.get('IPMI_PASSWORD')
state.ipmi_username = os.environ.get('IPMI_USERNAME')
if not state.ipmi_username:
state.ipmi_username = 'root'
log.info(f'Using the default IPMI username. Set the IPMI_USERNAME environment variable to change this.')
log.info(f'ipmi username: {state.ipmi_username}')
sls_actions = create_sls_actions(session, state)
print_actions(sls_actions)
# ncn-m001 does not use DHCP. It is assigned a static IP.
state.run_ipmitool = state.ncn_name != 'ncn-m001'
validate_ipmi_config(state)
bss_actions = create_bss_actions(session, state)
print_actions(bss_actions)
hsm_actions = create_hsm_actions(session, state)
print_actions(hsm_actions)
kea_actions = []
if not args.skip_kea:
kea_actions = create_kea_actions(session, state)
print_actions(kea_actions)
restart_bss_restart_actions = create_restart_bss_restart_actions()
print_command_actions(restart_bss_restart_actions)
restart_bss_wait_actions = create_restart_bss_wait_actions()
print_command_actions(restart_bss_wait_actions)
etc_hosts_actions = []
if not args.skip_etc_hosts:
etc_hosts_actions = create_update_etc_hosts_actions(state)
print_command_actions(etc_hosts_actions)
ipmitool_bmc_mac_actions = create_ipmitool_bmc_mac_actions(state)
print_command_actions(ipmitool_bmc_mac_actions)
ipmitool_set_dhcp_actions = create_ipmitool_set_bmc_to_dhcp_actions(state)
print_command_actions(ipmitool_set_dhcp_actions)
check_for_running_pods_on_ncn(state)
log.info('')
print_summary(state)
if not args.dry_run:
if not args.force:
print()
response = input(f'Permanently remove {state.xname} - {state.ncn_name} (y/n)? ')
if response.lower() != 'y':
log.info('Operation aborted. Nothing was removed.')
exit(0)
print()
log.info(f'Removing {args.xname}')
run_actions(session, bss_actions)
run_actions(session, hsm_actions)
run_actions(session, sls_actions)
run_actions(session, kea_actions)
log.info('Restarting cray-bss')
run_command_actions(restart_bss_restart_actions)
log.info('Waiting for cray-bss to start.')
log.info('Do not kill this script. The wait will timeout in 10 minutes if bss does not fully start up.')
run_command_actions(restart_bss_wait_actions)
# Set the BMC to DHCP
run_command_actions(ipmitool_set_dhcp_actions)
run_command_actions(etc_hosts_actions)
log.info('')
print_summary(state)
if not args.dry_run:
log.info('')
log.info(f'Successfully removed {state.
|
[
"xname",
"ncn_name",
"parent",
"run_ipmitool",
"ipmi_username",
"aliases",
"bmc_mac",
"directory",
"hsm_macs",
"ifnames",
"ip_reservation_aliases",
"ip_reservation_ips",
"ipmi_password",
"remove_ips",
"save",
"verbose",
"workers"
] |
actions)
restart_bss_wait_actions = create_restart_bss_wait_actions()
print_command_actions(restart_bss_wait_actions)
etc_hosts_actions = []
if not args.skip_etc_hosts:
etc_hosts_actions = create_update_etc_hosts_actions(state)
print_command_actions(etc_hosts_actions)
ipmitool_bmc_mac_actions = create_ipmitool_bmc_mac_actions(state)
print_command_actions(ipmitool_bmc_mac_actions)
ipmitool_set_dhcp_actions = create_ipmitool_set_bmc_to_dhcp_actions(state)
print_command_actions(ipmitool_set_dhcp_actions)
check_for_running_pods_on_ncn(state)
log.info('')
print_summary(state)
if not args.dry_run:
if not args.force:
print()
response = input(f'Permanently remove {state.xname} - {state.ncn_name} (y/n)? ')
if response.lower() != 'y':
log.info('Operation aborted. Nothing was removed.')
exit(0)
print()
log.info(f'Removing {args.xname}')
run_actions(session, bss_actions)
run_actions(session, hsm_actions)
run_actions(session, sls_actions)
run_actions(session, kea_actions)
log.info('Restarting cray-bss')
run_command_actions(restart_bss_restart_actions)
log.info('Waiting for cray-bss to start.')
log.info('Do not kill this script. The wait will timeout in 10 minutes if bss does not fully start up.')
run_command_actions(restart_bss_wait_actions)
# Set the BMC to DHCP
run_command_actions(ipmitool_set_dhcp_actions)
run_command_actions(etc_hosts_actions)
log.info('')
print_summary(state)
if not args.dry_run:
log.info('')
log.info(f'Successfully removed {state.
| 857
|
1,386
| 36
| 36,805
|
cray-hpe__docs-csm
|
3aeddea9f5df21148c84af36f97fed541a4ab1f5
|
scripts/operations/node_management/Add_Remove_Replace_NCNs/remove_management_ncn.py
|
infile
|
ncn_name
| true
|
statement
| 17
| 17
| false
| false
|
[
"xname",
"ncn_name",
"parent",
"run_ipmitool",
"ipmi_username",
"__init__",
"aliases",
"bmc_mac",
"directory",
"hsm_macs",
"ifnames",
"ip_reservation_aliases",
"ip_reservation_ips",
"ipmi_password",
"remove_ips",
"save",
"verbose",
"workers",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "aliases",
"type": "statement"
},
{
"name": "bmc_mac",
"type": "statement"
},
{
"name": "directory",
"type": "statement"
},
{
"name": "hsm_macs",
"type": "statement"
},
{
"name": "ifnames",
"type": "statement"
},
{
"name": "ip_reservation_aliases",
"type": "statement"
},
{
"name": "ip_reservation_ips",
"type": "statement"
},
{
"name": "ipmi_password",
"type": "statement"
},
{
"name": "ipmi_username",
"type": "statement"
},
{
"name": "ncn_name",
"type": "statement"
},
{
"name": "parent",
"type": "statement"
},
{
"name": "remove_ips",
"type": "statement"
},
{
"name": "run_ipmitool",
"type": "statement"
},
{
"name": "save",
"type": "function"
},
{
"name": "verbose",
"type": "statement"
},
{
"name": "workers",
"type": "statement"
},
{
"name": "xname",
"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"
}
] |
#!/usr/bin/env python3
# MIT License
#
# (C) Copyright [2022] Hewlett Packard Enterprise Development LP
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.
import argparse
import http
import json
import logging
import os
import pathlib
import re
import requests
import shutil
import subprocess
import sys
import urllib3
BASE_URL = ''
BSS_URL = ''
HSM_URL = ''
SLS_URL = ''
KEA_URL = ''
# This is the list of NCNs for which the IPs should not be removed from /etc/hosts
NCN_DO_NOT_REMOVE_IPS = [
'ncn-m001', 'ncn-m002', 'ncn-m003',
'ncn-w001', 'ncn-w002', 'ncn-w003',
'ncn-s001', 'ncn-s002', 'ncn-s003',
]
class Logger:
def __init__(self):
self.log_file = None
def init_logger(self, log_file, verbose=False):
self.log_file = log_file
if log_file:
if verbose:
logging.basicConfig(filename=log_file, filemode='w', level=logging.DEBUG,
format='%(levelname)s: %(message)s')
else:
logging.basicConfig(filename=log_file, filemode='w', level=logging.INFO,
format='%(levelname)s: %(message)s')
# the encoding argument is not in python 3.6.15
# logging.basicConfig(filename=log_file, filemode='w', level=logging.INFO, encoding='utf-8',
# format='%(levelname)s: %(message)s')
def info(self, message):
print(message)
if self.log_file:
logging.info(message)
def warning(self, message):
print(f'Warning: {message}')
if self.log_file:
logging.warning(message)
def error(self, message):
print(f'Error: {message}')
if self.log_file:
logging.error(message)
log = Logger()
class State:
def __init__(self, xname=None, directory=None, dry_run=False, verbose=False):
self.xname = xname
self.parent = None
self.ncn_name = ""
self.aliases = set()
self.ip_reservation_aliases = set()
self.ip_reservation_ips = set()
self.hsm_macs = set()
self.workers = set()
self.remove_ips = True
self.ifnames = []
self.bmc_mac = None
self.verbose = verbose
self.ipmi_username = None
self.ipmi_password = None
self.run_ipmitool = False
if directory and xname:
self.directory = os.path.join(directory, xname)
else:
self.directory = directory
if self.directory:
# todo possibly add check that prevents saved files from being overwritten
# file_list = os.listdir(self.directory)
# if 'dry-run' in file_list:
# # continue because the previous run was a dry-run
# pass
# elif len(os.listdir(self.directory)) != 0:
# print(f'Error: Save directory is not empty: {self.directory}. Use --force option to over write it.')
# sys.exit(1)
dry_run_flag_file = os.path.join(self.directory, 'dry-run')
# remove directory if previous run was a dry run
if os.path.exists(dry_run_flag_file):
shutil.rmtree(self.directory)
# create the directory
if not os.path.exists(self.directory):
os.makedirs(self.directory)
if dry_run:
pathlib.Path(dry_run_flag_file).touch()
else:
if os.path.exists(dry_run_flag_file):
os.remove(dry_run_flag_file)
def save(self, name, data):
if self.directory:
file = os.path.join(self.directory, f'{name}.json')
with open(file, 'w', encoding='utf-8') as f:
json.dump(data, f, ensure_ascii=False, indent=2)
class CommandAction:
def __init__(self, command, verbose=False):
self.command = command
self.has_run = False
self.return_code = -1
self.stdout = None
self.stderr = None
self.verbose = verbose
class HttpAction:
def __init__(self, method, url, logs=None, request_body="", response_body="", completed=False, success=False):
self.method = method
self.url = url
self.logs = [] if logs is None else logs
self.request_body = request_body
self.response_body = response_body
self.completed = completed
self.success = success
self.response = None
def log(self, message):
self.logs.append(message)
def get_response_body(self, default_value=None):
if default_value is None:
return self.response_body
if self.response_body:
return self.response_body
return default_value
def setup_urls(args):
global BASE_URL
global BSS_URL
global HSM_URL
global SLS_URL
global KEA_URL
if args.base_url:
BASE_URL = args.base_url
else:
BASE_URL = 'https://api-gw-service-nmn.local/apis'
if args.bss_url:
BSS_URL = args.bss_url
elif args.test_urls:
BSS_URL = 'http://localhost:27778/boot/v1'
else:
BSS_URL = f'{BASE_URL}/bss/boot/v1'
if args.hsm_url:
HSM_URL = args.hsm_url
elif args.test_urls:
HSM_URL = 'http://localhost:27779/hsm/v2'
else:
HSM_URL = f'{BASE_URL}/smd/hsm/v2'
if args.sls_url:
SLS_URL = args.sls_url
elif args.test_urls:
SLS_URL = 'http://localhost:8376/v1'
else:
SLS_URL = f'{BASE_URL}/sls/v1'
KEA_URL = f'{BASE_URL}/dhcp-kea'
def print_urls():
log.info(f'BSS_URL: {BSS_URL}')
log.info(f'HSM_URL: {HSM_URL}')
log.info(f'SLS_URL: {SLS_URL}')
log.info(f'KEA_URL: {KEA_URL}')
def print_summary(state):
log.info('Summary:')
log.info(f' Logs: {state.directory}')
log.info(f' xname: {state.xname}')
log.info(f' ncn_name: {state.ncn_name}')
log.info(f' ncn_macs:')
log.info(f' ifnames: {", ".join(state.ifnames)}')
log.info(f' bmc_mac: {state.bmc_mac if state.bmc_mac else "Unknown"}')
def print_action(action):
if action.completed:
if action.success:
log.info(f"Called: {action.method.upper()} {action.url}")
else:
log.error(f"Failed: {action.method.upper()} {action.url}")
log.info(json.dumps(action.response_body, indent=2))
else:
log.info(f"Planned: {action.method.upper()} {action.url}")
for a_log in action.logs:
log.info(' ' + a_log)
def print_actions(actions):
for action in actions:
print_action(action)
def print_command_action(action):
if action.has_run:
log.info(f'Ran: {" ".join(action.command)}')
if action.return_code != 0:
log.error(f' Failed: {action.return_code}')
log.info(f' stdout:\n{action.stdout}')
log.info(f' stderr:\n{action.stderr}')
elif action.verbose:
log.info(f' stdout:\n{action.stdout}')
if action.stderr:
log.info(f' stderr:\n{action.stderr}')
else:
log.info(f'Planned: {" ".join(action.command)}')
def print_command_actions(actions):
for action in actions:
print_command_action(action)
def http_get(session, actions, url, exit_on_error=True):
r = session.get(url)
action = HttpAction('get', url, response_body=r.text, completed=True)
actions.append(action)
action.response = r
if r.status_code == http.HTTPStatus.OK:
action.success = True
elif exit_on_error:
log_error_and_exit(actions, str(action))
return action
def log_error_and_exit(actions, message):
print_actions(actions)
log.error(f'{message}')
sys.exit(1)
def node_bmc_to_enclosure(xname_for_bmc):
p = re.compile('^(x[0-9]{1,4}c0s[0-9]+)(b)([0-9]+)$')
if p.match(xname_for_bmc):
# convert node bmc to enclosure, for example, convert x3000c0s36b0 to x3000c0s36e0
enclosure = re.sub(p, r'\1e\3', xname_for_bmc)
return enclosure
return None
def add_delete_action_if_component_present(actions, state, session, url, save_file):
action = http_get(session, actions, url, exit_on_error=False)
if action.success:
state.save(save_file, json.loads(action.response_body))
actions.append(HttpAction('delete', url))
not_found = action.response.status_code == http.HTTPStatus.NOT_FOUND
if not_found:
action.success = True
action.log('The item does not need to be deleted, because it does not exist.')
def validate_ipmi_config(state):
if state.run_ipmitool:
if not state.ipmi_password:
log.error('IPMI_PASSWORD not set')
log.error('The environment variable IPMI_PASSWORD is required')
log.error('It should be set to the password of the BMC that is being removed')
sys.exit(1)
if not state.ipmi_username:
log.error('IPMI_USERNAME not set')
log.error('The environment variable IPMI_USERNAME is required')
log.error('It should be set to the username of the BMC that is being removed')
sys.exit(1)
def create_sls_actions(session, state):
actions = []
hardware_action = http_get(session, actions, f'{SLS_URL}/hardware')
networks_action = http_get(session, actions, f'{SLS_URL}/networks')
# Find xname in hardware and get aliases
found_hardware_for_xname = False
hardware_list = json.loads(hardware_action.response_body)
for hardware in hardware_list:
extra_properties = hardware.get('ExtraProperties', {})
if state.xname == hardware['Xname']:
type_string = hardware.get('TypeString')
role = extra_properties.get('Role')
sub_role = extra_properties.get('SubRole')
if type_string != 'Node' or role != 'Management' or sub_role not in ['Worker', 'Storage', 'Master']:
log_error_and_exit(
actions,
f'{state.xname} is Type: {type_string}, Role: {role}, SubRole: {sub_role}. ' +
'The node must be Type: Node, Role: Management, SubRole: one of Worker, Storage, or Master.')
found_hardware_for_xname = True
state.save(f'sls-hardware-{state.xname}', hardware)
state.parent = hardware.get('Parent')
hardware_action.log(
f'Found Hardware: Xname: {state.xname}, ' +
f'Parent: {state.parent}, ' +
f'TypeString: {hardware["TypeString"]}, ' +
f'Role: {hardware.get("ExtraProperties").get("Role")}')
state.aliases.update(extra_properties.get('Aliases', []))
hardware_action.log(f'Aliases: {state.aliases}')
alias_count = len(state.aliases)
if alias_count != 1:
log.warning(f'Expected to find only one alias. Instead found {state.aliases}')
if alias_count > 0:
state.ncn_name = list(state.aliases)[0]
log.info(f'xname: {state.xname}')
log.info(f'ncn name: {state.ncn_name}')
if state.ncn_name in NCN_DO_NOT_REMOVE_IPS:
state.remove_ips = False
# Requires that the parent is known.
# The loop through the hardware_list above finds the given node and parent
# That is why this must loop through the hardware list again after the loop above.
hardware_connectors = []
for hardware in hardware_list:
extra_properties = hardware.get('ExtraProperties', {})
# Check for nic connections
for nic in extra_properties.get("NodeNics", []):
if nic == state.parent:
hardware_connectors.append(hardware.get('Xname'))
state.save(f'sls-hardware-{hardware.get("Xname")}', hardware)
hardware_action.log(f'Found Connector Hardware: Xname: {hardware.get("Xname")}, NodeNic: {nic}')
type_string = hardware.get('TypeString')
role = extra_properties.get('Role')
sub_role = extra_properties.get('SubRole')
if type_string == 'Node' and role == 'Management' and sub_role in ['Worker', 'Storage', 'Master']:
aliases = extra_properties.get('Aliases', [])
for alias in aliases:
if alias not in state.aliases:
state.workers.add(alias)
for connector in hardware_connectors:
actions.append(HttpAction('delete', f'{SLS_URL}/hardware/{connector}'))
if found_hardware_for_xname:
actions.append(HttpAction('delete', f'{SLS_URL}/hardware/{state.xname}'))
state.save('sls-hardware', hardware_list)
else:
log_error_and_exit(actions, f'Failed to find sls hardware entry for xname: {state.xname}')
# Find network references for the aliases and the parent
networks = json.loads(networks_action.response_body)
state.save('sls-networks', networks)
for network in networks:
network_name = network.get("Name")
if network_name == 'HSN':
# Skip the HSN network. This network is owned by slingshot.
continue
logs = []
network_has_changes = False
extra_properties = network.get('ExtraProperties')
subnets = extra_properties['Subnets']
if subnets is None:
continue
for subnet in subnets:
ip_reservations = subnet.get('IPReservations')
if ip_reservations is None:
continue
new_ip_reservations = []
subnet_has_changes = False
for ip_reservation in ip_reservations:
rname = ip_reservation['Name']
if rname not in state.aliases and rname != state.parent and rname != state.xname:
new_ip_reservations.append(ip_reservation)
else:
subnet_has_changes = True
a = ip_reservation.get('Aliases')
if a:
state.ip_reservation_aliases.update(ip_reservation.get('Aliases'))
state.ip_reservation_aliases.add(ip_reservation.get('Name'))
state.ip_reservation_ips.add(ip_reservation.get('IPAddress'))
if state.remove_ips:
logs.append(
f'Removed IP Reservation in {network["Name"]} ' +
f'in subnet {subnet["Name"]} for {ip_reservation["Name"]}')
logs.append(
'IP Reservation Details: ' +
f'Name: {ip_reservation.get("Name")}, ' +
f'IPAddress: {ip_reservation.get("IPAddress")}, ' +
f'Aliases: {ip_reservation.get("Aliases")}')
state.save(f'sls-ip-reservation-{network["Name"]}-{subnet["Name"]}-{ip_reservation["Name"]}',
ip_reservation)
if state.remove_ips and subnet_has_changes:
network_has_changes = True
subnet['IPReservations'] = new_ip_reservations
if state.remove_ips and network_has_changes:
request_body = json.dumps(network)
action = HttpAction(
'put', f'{SLS_URL}/networks/{network["Name"]}', logs=logs, request_body=request_body)
actions.append(action)
return actions
def create_hsm_actions(session, state):
actions = []
# xname ethernet interfaces
ethernet_xname_action = http_get(session, actions,
f'{HSM_URL}/Inventory/EthernetInterfaces?ComponentId={state.xname}')
ethernet_list = json.loads(ethernet_xname_action.response_body)
for ethernet in ethernet_list:
ethernet_id = ethernet.get('ID')
actions.append(HttpAction('delete', f'{HSM_URL}/Inventory/EthernetInterfaces/{ethernet_id}'))
state.save(f'hsm-ethernet-interface-{ethernet_id}', ethernet)
mac = ethernet.get('MACAddress')
if mac:
state.hsm_macs.add(mac)
# bmc (parent) ethernet interfaces
ethernet_parent_action = http_get(session, actions,
f'{HSM_URL}/Inventory/EthernetInterfaces?ComponentId={state.parent}')
ethernet_list = json.loads(ethernet_parent_action.response_body)
for ethernet in ethernet_list:
ethernet_id = ethernet.get('ID')
actions.append(HttpAction('delete', f'{HSM_URL}/Inventory/EthernetInterfaces/{ethernet_id}'))
state.save(f'hsm-ethernet-interface-{ethernet_id}', ethernet)
mac = ethernet.get('MACAddress')
if mac:
state.hsm_macs.add(mac)
# delete parent redfish endpoints
add_delete_action_if_component_present(
actions, state, session, f'{HSM_URL}/Inventory/RedfishEndpoints/{state.parent}', f'hsm-redfish-endpoints-{state.parent}')
# delete xname from component state
add_delete_action_if_component_present(
actions, state, session, f'{HSM_URL}/State/Components/{state.xname}', f'hsm-component-{state.xname}')
# delete parent from component state
add_delete_action_if_component_present(
actions, state, session, f'{HSM_URL}/State/Components/{state.parent}', f'hsm-component-{state.parent}')
# delete node enclosure for parent from component state
node_enclosure_xname = node_bmc_to_enclosure(state.parent)
if node_enclosure_xname:
add_delete_action_if_component_present(
actions, state, session, f'{HSM_URL}/State/Components/{node_enclosure_xname}', f'hsm-component-{node_enclosure_xname}')
else:
log.error(f'failed to create enclosure xname for parent {state.parent}')
return actions
def bss_params_to_ifnames(params):
result = []
arg_list = params.split(' ')
for arg in arg_list:
if arg.startswith('ifname='):
key_value = arg.split('=', 2)
result.append(key_value[1])
return result
def create_bss_actions(session, state):
actions = []
global_bp_action = http_get(session, actions, f'{BSS_URL}/bootparameters?name=Global')
global_bp = json.loads(global_bp_action.response_body)
if len(global_bp) == 0:
log_error_and_exit(actions, "Failed to find Global bootparameters")
elif len(global_bp) > 1:
log.error("unexpectedly found more than one Global bootparameters. Continuing with the only the first entry")
boot_parameter = global_bp[0]
state.save('bss-bootparameters-global', boot_parameter)
# check that ncn being removed is not first master
first_master = boot_parameter.get('cloud-init', {}).get('meta-data', {}).get('first-master-hostname')
if first_master == state.ncn_name:
log_error_and_exit(actions,
'Cannot remove the first master. ' +
f'xname: {state.xname}, ncn-name: {state.ncn_name}, first-master-hostname: {first_master}')
else:
global_bp_action.log(f'first-master-hostname: {first_master}')
# remove host records from Global boot parameters
if state.remove_ips:
host_records = boot_parameter.get('cloud-init').get('meta-data').get('host_records')
new_host_records = []
has_changes = False
for host_record in host_records:
found_alias_match = False
for alias in host_record.get('aliases'):
for alias_prefix in state.aliases:
if alias.startswith(alias_prefix):
found_alias_match = True
if found_alias_match:
has_changes = True
else:
new_host_records.append(host_record)
if has_changes:
boot_parameter.get('cloud-init').get('meta-data')['host_records'] = new_host_records
global_request_body = json.dumps(boot_parameter)
state.save('new-bss-bootparameters-global', boot_parameter)
actions.append(HttpAction('put', f'{BSS_URL}/bootparameters', request_body=global_request_body))
# remove boot parameters for xname
xname_bp_action = http_get(session, actions, f'{BSS_URL}/bootparameters?name={state.xname}')
if xname_bp_action.success:
xname_bp_list = json.loads(xname_bp_action.response_body)
xname_bp = xname_bp_list[0] if len(xname_bp_list) > 0 else {}
state.save(f'bss-bootparameters-{state.xname}', xname_bp_list)
# create delete action
delete_request_body = '{ "hosts" : [ "' + state.xname + '" ] }'
xname_bp_delete_action = HttpAction('delete', f'{BSS_URL}/bootparameters', request_body=delete_request_body)
xname_bp_delete_action.log(delete_request_body)
actions.append(xname_bp_delete_action)
# save interfaces from params
params = xname_bp.get('params')
if params:
state.ifnames = bss_params_to_ifnames(params)
return actions
def create_kea_actions(session, state):
actions = []
for mac in sorted(state.hsm_macs):
request_body = '{"command": "lease4-get-by-hw-address", "service": [ "dhcp4" ], "arguments": {"hw-address": "' + mac + '"}}'
action = HttpAction('post', f'{KEA_URL}', request_body=request_body)
actions.append(action)
action.log(f'Request body: {request_body}')
run_action(session, action)
if state.verbose:
action.log(f'Response body: {action.response_body}')
if action.success:
response = action.get_response_body('[]')
response_json = json.loads(response)
for r in response_json:
leases = r.get("arguments", {}).get("leases", [])
for lease in leases:
ip = lease.get('ip-address')
if ip:
if ip not in state.ip_reservation_ips:
state.ip_reservation_ips.add(ip)
action.log(f'Added {ip} to the list of kea leases to remove')
for ip in sorted(state.ip_reservation_ips):
request_body = '{"command": "lease4-del", "service": [ "dhcp4" ], "arguments": {"ip-address": "' + ip + '"}}'
action = HttpAction('post', f'{KEA_URL}', request_body=request_body)
actions.append(action)
action.log(f'Request body: {request_body}')
return actions
def run_command(command):
cmd = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
result = cmd.communicate()
stdout = None if not result[0] else result[0].decode('utf-8')
stderr = None if not result[1] else result[1].decode('utf-8')
return cmd.returncode, stdout, stderr
def run_command_action(command):
command.return_code, command.stdout, command.stderr = run_command(command.command)
command.has_run = True
def run_command_actions(command_actions):
for command in command_actions:
if command.has_run:
pass
else:
run_command_action(command)
print_command_action(command)
def check_for_running_pods_on_ncn(state):
for alias in state.aliases:
command_wide = ['kubectl', 'get', 'pods', '--all-namespaces', '--field-selector', f'spec.nodeName={alias}', '-o', 'wide']
command = ['kubectl', 'get', 'pods', '--all-namespaces', '--field-selector', f'spec.nodeName={alias}', '-o', 'json']
return_code, stdout, stderr = run_command(command)
log.info("Ran: " + ' '.join(command))
if return_code != 0:
log.error('kubectl command failed')
log.info(f'Return code: {return_code}')
log.info(f'Standard out:\n{stdout}')
log.info(f'Standard err:\n{stderr}')
sys.exit(1)
if stdout:
response = json.loads(stdout)
items = response.get('items')
if items is not None:
if len(items) != 0:
log.info(' '.join(command_wide))
_, wide_stdout, wide_stderr = run_command(command_wide)
log.info(wide_stdout)
if wide_stderr:
log.info(wide_stderr)
log.error(f'there are pods on {alias}.')
sys.exit(1)
else:
print(
f'Warning: Could not determine if {alias} is running services. Command did not return the expected json')
else:
print(f'Warning: Could not determine if {alias} is running services. Command returned no output.')
def create_restart_bss_restart_actions():
return [
CommandAction(['kubectl', '-n', 'services', 'rollout', 'restart', 'deployment', 'cray-bss']),
]
def create_restart_bss_wait_actions():
return [
CommandAction(['kubectl', '-n', 'services', 'rollout', 'status', 'deployment', 'cray-bss', '--timeout=600s']),
]
def create_update_etc_hosts_actions(state):
command_actions = []
if state.remove_ips:
sorted_workers = sorted(state.workers)
for worker in sorted_workers:
scp_action = CommandAction(['scp', f'{worker}:/etc/hosts', f'{state.directory}/etc-hosts-{worker}'])
command_actions.append(scp_action)
hosts = ','.join(sorted_workers)
cp_backup_action = CommandAction(['pdsh', '-w', hosts,
'cp', '/etc/hosts', f'/tmp/hosts.backup.{state.xname}.{state.ncn_name}'])
command_actions.append(cp_backup_action)
for ip in sorted(state.ip_reservation_ips):
sed_action = CommandAction(['pdsh', '-w', hosts,
'sed', '-i', f'/^{ip}[[:blank:]]/d', f'/etc/hosts'])
command_actions.append(sed_action)
else:
print('Leaving /etc/hosts unchanged')
return command_actions
def create_ipmitool_set_bmc_to_dhcp_actions(state):
command_actions = []
if not state.run_ipmitool:
return command_actions
if not state.ncn_name or not state.ipmi_password or not state.ipmi_username:
# hitting this case is a programming error.
# these values should have been checked by calling validate_ipmi_config(state)
log.error('Unexpected state. Missing one of these values: ncn_name: ' +
f'"{state.ncn_name}", ipmi_username: "{state.ipmi_username}", ipmi_password: "****"')
return command_actions
mc_info_action = CommandAction([
'ipmitool', '-I', 'lanplus', '-U', state.ipmi_username, '-E', '-H', f'{state.ncn_name}-mgmt',
'mc', 'info'],
verbose=state.verbose)
command_actions.append(mc_info_action)
run_command_action(mc_info_action)
lan = '1'
if mc_info_action.stdout:
manufacturer_lines = [line for line in mc_info_action.stdout.split('\n') if 'manufacturer name' in line.lower()]
for line in manufacturer_lines:
if 'intel' in line.lower():
lan = '3'
# Set the BMC to DHCP
change_dhcp_action = CommandAction([
'ipmitool', '-I', 'lanplus', '-U', state.ipmi_username, '-E', '-H', f'{state.ncn_name}-mgmt',
'lan', 'set', lan, "ipsrc", "dhcp"],
verbose=state.verbose)
command_actions.append(change_dhcp_action)
# Restart BMC
restart_bmc_action = CommandAction([
'ipmitool', '-I', 'lanplus', '-U', state.ipmi_username, '-E', '-H', f'{state.ncn_name}-mgmt',
'mc', 'reset', "cold"],
verbose=state.verbose)
command_actions.append(restart_bmc_action)
return command_actions
def create_ipmitool_bmc_mac_actions(state):
command_actions = []
if not state.run_ipmitool:
return command_actions
if not state.ncn_name or not state.ipmi_password or not state.ipmi_username:
# hitting this case is a programming error.
# these values should have been checked by calling validate_ipmi_config(state)
log.error('Unexpected state. Missing one of these values: ncn_name: ' +
f'"{state.ncn_name}", ipmi_username: "{state.ipmi_username}", ipmi_password: "****"')
return command_actions
mc_info_action = CommandAction([
'ipmitool', '-I', 'lanplus', '-U', state.ipmi_username, '-E', '-H', f'{state.ncn_name}-mgmt',
'mc', 'info'],
verbose=state.verbose)
command_actions.append(mc_info_action)
run_command_action(mc_info_action)
lan = '1'
if mc_info_action.stdout:
manufacturer_lines = [line for line in mc_info_action.stdout.split('\n') if 'manufacturer name' in line.lower()]
for line in manufacturer_lines:
if 'intel' in line.lower():
lan = '3'
mac_action = CommandAction([
'ipmitool', '-I', 'lanplus', '-U', state.ipmi_username, '-E', '-H', f'{state.ncn_name}-mgmt',
'lan', 'print', lan],
verbose=state.verbose)
command_actions.append(mac_action)
run_command_action(mac_action)
if mac_action.return_code == 0 and mac_action.stdout:
mac_lines = [line for line in mac_action.stdout.split('\n') if 'mac address' in line.lower()]
for line in mac_lines:
key_value = line.split(':', 1)
if len(key_value) == 2:
state.bmc_mac = key_value[1].strip()
return command_actions
def is_2xx(http_status):
return http_status // 200 == 1
def run_action(session, action):
method = action.method
url = action.url
r = None
if method == 'get':
r = session.get(url)
elif method == 'delete':
r = session.delete(url, data=action.request_body)
elif method == 'put':
r = session.put(url, action.request_body)
elif method == 'post':
r = session.post(url, action.request_body)
else:
print(f"Unknown method {method}")
print("FAILED")
sys.exit(1)
if r:
action.response_body = r.text
action.completed = True
action.success = is_2xx(r.status_code)
def run_actions(session, actions):
for action in actions:
if action.completed:
print_action(action)
else:
run_action(session, action)
print_action(action)
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument('--xname', help='The xname of the ncn to remove', required=True)
parser.add_argument('--dry-run', action='store_true', help='Do a dry run where nothing is modified')
parser.add_argument('--log-dir', '-l', default='/tmp/remove_management_ncn',
help='Directory where to log and save current state.')
parser.add_argument("-v", action="store_true", help="Print verbose output")
# hidden arguments used for testing
parser.add_argument('--base-url', help=argparse.SUPPRESS) # Base url.
parser.add_argument('--sls-url', help=argparse.SUPPRESS) # Base url for sls. Overrides --base-url
parser.add_argument('--hsm-url', help=argparse.SUPPRESS) # Base url for hsm. Overrides --base-url
parser.add_argument('--bss-url', help=argparse.SUPPRESS) # Base url for bss. Overrides --base-url
parser.add_argument('-t', '--test-urls', action='store_true', help=argparse.SUPPRESS) # Use test urls
parser.add_argument('--skip-kea', action='store_true', help=argparse.SUPPRESS) # skip kea actions
parser.add_argument('--skip-etc-hosts', action='store_true', help=argparse.SUPPRESS) # skip /etc/hosts actions
parser.add_argument('--force', action='store_true', help=argparse.SUPPRESS) # skip asking 'are you sure' question
args = parser.parse_args()
state = State(xname=args.xname, directory=args.log_dir, dry_run=args.dry_run, verbose=args.v)
log.init_logger(os.path.join(state.directory, 'log'), verbose=state.verbose)
setup_urls(args)
print_urls()
with requests.Session() as session:
session.verify = False
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
token = os.environ.get('TOKEN')
if token is not None:
session.headers.update({'Authorization': f'Bearer {token}'})
elif not args.test_urls and token is None:
log.error('The TOKEN environment variable is not set.')
log.info('Run the following to set the TOKEN:')
log.info('''export TOKEN=$(curl -s -S -d grant_type=client_credentials \\
-d client_id=admin-client -d client_secret=`kubectl get secrets admin-client-auth \\
-o jsonpath='{.data.client-secret}' | base64 -d` \\
https://api-gw-service-nmn.local/keycloak/realms/shasta/protocol/openid-connect/token \\
| jq -r '.access_token')
''')
sys.exit(1)
session.headers.update({'Content-Type': 'application/json'})
state.ipmi_password = os.environ.get('IPMI_PASSWORD')
state.ipmi_username = os.environ.get('IPMI_USERNAME')
if not state.ipmi_username:
state.ipmi_username = 'root'
log.info(f'Using the default IPMI username. Set the IPMI_USERNAME environment variable to change this.')
log.info(f'ipmi username: {state.ipmi_username}')
sls_actions = create_sls_actions(session, state)
print_actions(sls_actions)
# ncn-m001 does not use DHCP. It is assigned a static IP.
state.run_ipmitool = state.ncn_name != 'ncn-m001'
validate_ipmi_config(state)
bss_actions = create_bss_actions(session, state)
print_actions(bss_actions)
hsm_actions = create_hsm_actions(session, state)
print_actions(hsm_actions)
kea_actions = []
if not args.skip_kea:
kea_actions = create_kea_actions(session, state)
print_actions(kea_actions)
restart_bss_restart_actions = create_restart_bss_restart_actions()
print_command_actions(restart_bss_restart_actions)
restart_bss_wait_actions = create_restart_bss_wait_actions()
print_command_actions(restart_bss_wait_actions)
etc_hosts_actions = []
if not args.skip_etc_hosts:
etc_hosts_actions = create_update_etc_hosts_actions(state)
print_command_actions(etc_hosts_actions)
ipmitool_bmc_mac_actions = create_ipmitool_bmc_mac_actions(state)
print_command_actions(ipmitool_bmc_mac_actions)
ipmitool_set_dhcp_actions = create_ipmitool_set_bmc_to_dhcp_actions(state)
print_command_actions(ipmitool_set_dhcp_actions)
check_for_running_pods_on_ncn(state)
log.info('')
print_summary(state)
if not args.dry_run:
if not args.force:
print()
response = input(f'Permanently remove {state.xname} - {state.ncn_name} (y/n)? ')
if response.lower() != 'y':
log.info('Operation aborted. Nothing was removed.')
exit(0)
print()
log.info(f'Removing {args.xname}')
run_actions(session, bss_actions)
run_actions(session, hsm_actions)
run_actions(session, sls_actions)
run_actions(session, kea_actions)
log.info('Restarting cray-bss')
run_command_actions(restart_bss_restart_actions)
log.info('Waiting for cray-bss to start.')
log.info('Do not kill this script. The wait will timeout in 10 minutes if bss does not fully start up.')
run_command_actions(restart_bss_wait_actions)
# Set the BMC to DHCP
run_command_actions(ipmitool_set_dhcp_actions)
run_command_actions(etc_hosts_actions)
log.info('')
print_summary(state)
if not args.dry_run:
log.info('')
log.info(f'Successfully removed {state.xname} - {state.
|
[
"xname",
"ncn_name",
"parent",
"run_ipmitool",
"ipmi_username",
"aliases",
"bmc_mac",
"directory",
"hsm_macs",
"ifnames",
"ip_reservation_aliases",
"ip_reservation_ips",
"ipmi_password",
"remove_ips",
"save",
"verbose",
"workers"
] |
restart_bss_wait_actions = create_restart_bss_wait_actions()
print_command_actions(restart_bss_wait_actions)
etc_hosts_actions = []
if not args.skip_etc_hosts:
etc_hosts_actions = create_update_etc_hosts_actions(state)
print_command_actions(etc_hosts_actions)
ipmitool_bmc_mac_actions = create_ipmitool_bmc_mac_actions(state)
print_command_actions(ipmitool_bmc_mac_actions)
ipmitool_set_dhcp_actions = create_ipmitool_set_bmc_to_dhcp_actions(state)
print_command_actions(ipmitool_set_dhcp_actions)
check_for_running_pods_on_ncn(state)
log.info('')
print_summary(state)
if not args.dry_run:
if not args.force:
print()
response = input(f'Permanently remove {state.xname} - {state.ncn_name} (y/n)? ')
if response.lower() != 'y':
log.info('Operation aborted. Nothing was removed.')
exit(0)
print()
log.info(f'Removing {args.xname}')
run_actions(session, bss_actions)
run_actions(session, hsm_actions)
run_actions(session, sls_actions)
run_actions(session, kea_actions)
log.info('Restarting cray-bss')
run_command_actions(restart_bss_restart_actions)
log.info('Waiting for cray-bss to start.')
log.info('Do not kill this script. The wait will timeout in 10 minutes if bss does not fully start up.')
run_command_actions(restart_bss_wait_actions)
# Set the BMC to DHCP
run_command_actions(ipmitool_set_dhcp_actions)
run_command_actions(etc_hosts_actions)
log.info('')
print_summary(state)
if not args.dry_run:
log.info('')
log.info(f'Successfully removed {state.xname} - {state.
| 858
|
1,389
| 38
| 910
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/durable_rules_engine.py
|
infile
|
assert_fact
| true
|
function
| 9
| 9
| false
| true
|
[
"__host",
"__last_resp",
"assert_fact",
"get_facts",
"retract_fact",
"__init__",
"assert_event",
"complete_and_start_action",
"create_ruleset",
"start_action_for_state",
"__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_event",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "start_action_for_state",
"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": "__host",
"type": "statement"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__last_resp",
"type": "statement"
},
{
"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 logging
import requests
_logger = logging.getLogger(__name__)
class DurableRulesEngine:
__host = None
__last_resp = None
def __init__(self, host):
self.__host = host
def create_ruleset(self, ruleset_name, ruleset_string): # real signature unknown
# {
# "sid": "0",
# "id": "sid-0",
# "$s": 1
# }
req = {ruleset_name: json.loads(ruleset_string)}
r = requests.post(self.__host + '/create-durable-rules-executor', json=req)
if r.status_code != 200:
raise Exception(f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
id = r.text
return id
def assert_event(self, session_id, serialized_fact):
_logger.warning("assert_event not yet implemented: using assert_fact")
return self.
|
[
"assert_fact",
"get_facts",
"retract_fact",
"assert_event",
"complete_and_start_action",
"create_ruleset",
"start_action_for_state"
] |
import json
import logging
import requests
_logger = logging.getLogger(__name__)
class DurableRulesEngine:
__host = None
__last_resp = None
def __init__(self, host):
self.__host = host
def create_ruleset(self, ruleset_name, ruleset_string): # real signature unknown
# {
# "sid": "0",
# "id": "sid-0",
# "$s": 1
# }
req = {ruleset_name: json.loads(ruleset_string)}
r = requests.post(self.__host + '/create-durable-rules-executor', json=req)
if r.status_code != 200:
raise Exception(f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
id = r.text
return id
def assert_event(self, session_id, serialized_fact):
_logger.warning("assert_event not yet implemented: using assert_fact")
return self.
| 860
|
1,397
| 38
| 3,632
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/durable_rules_engine.py
|
infile
|
assert_fact
| true
|
function
| 7
| 7
| false
| false
|
[
"assert_fact",
"get_facts",
"retract_fact",
"create_ruleset",
"start_action_for_state",
"__init__",
"assert_event",
"complete_and_start_action",
"__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_event",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "start_action_for_state",
"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 logging
import requests
_logger = logging.getLogger(__name__)
class DurableRulesEngine:
__host = None
__last_resp = None
def __init__(self, host):
self.__host = host
def create_ruleset(self, ruleset_name, ruleset_string): # real signature unknown
# {
# "sid": "0",
# "id": "sid-0",
# "$s": 1
# }
req = {ruleset_name: json.loads(ruleset_string)}
r = requests.post(self.__host + '/create-durable-rules-executor', json=req)
if r.status_code != 200:
raise Exception(f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
id = r.text
return id
def assert_event(self, session_id, serialized_fact):
_logger.warning("assert_event not yet implemented: using assert_fact")
return self.assert_fact(session_id, serialized_fact)
def assert_fact(self, session_id, serialized_fact):
d = json.loads(serialized_fact)
if 'j' in serialized_fact:
d['j'] = 1
serialized_fact = json.dumps(d)
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/process",
json=json.loads(serialized_fact))
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
self.__last_resp = r.json()
self.__last_resp.reverse()
# {
# "sid": "0",
# "id": "sid-0",
# "$s": 1
# }
return (0, session_id)
def start_action_for_state(self, handle): # real signature unknown
try:
resp = self.__last_resp.pop()
except:
return None
return ('{ "sid":"0", "id":"sid-0", "$s":1}', json.dumps(resp), handle)
def complete_and_start_action(self, handle): # real signature unknown
_logger.info("complete_and_start_action: %d", handle)
try:
resp = self.__last_resp.pop()
except:
return None
return json.dumps(resp)
def retract_fact(self, session_id, serialized_fact):
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/retract-fact",
json=json.loads(serialized_fact))
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
#self.__last_resp = r.json()
#self.__last_resp.reverse()
return (0, session_id)
def get_facts(self, session_id, _sid):
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/get-all-facts")
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
#self.__last_resp = r.json()
#self.__last_resp.reverse()
return r.content
class error(Exception):
# no doc
def __init__(self, *args, **kwargs): # real signature unknown
pass
__weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""list of weak references to the object (if defined)"""
# exported methods
__instance = DurableRulesEngine("http://localhost:8080")
def abandon_action(*args, **kwargs): # real signature unknown
pass
def assert_event(session_id, serialized_fact):
return __instance.
|
[
"assert_fact",
"get_facts",
"retract_fact",
"create_ruleset",
"start_action_for_state",
"assert_event",
"complete_and_start_action"
] |
te(self, handle): # real signature unknown
try:
resp = self.__last_resp.pop()
except:
return None
return ('{ "sid":"0", "id":"sid-0", "$s":1}', json.dumps(resp), handle)
def complete_and_start_action(self, handle): # real signature unknown
_logger.info("complete_and_start_action: %d", handle)
try:
resp = self.__last_resp.pop()
except:
return None
return json.dumps(resp)
def retract_fact(self, session_id, serialized_fact):
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/retract-fact",
json=json.loads(serialized_fact))
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
#self.__last_resp = r.json()
#self.__last_resp.reverse()
return (0, session_id)
def get_facts(self, session_id, _sid):
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/get-all-facts")
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
#self.__last_resp = r.json()
#self.__last_resp.reverse()
return r.content
class error(Exception):
# no doc
def __init__(self, *args, **kwargs): # real signature unknown
pass
__weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""list of weak references to the object (if defined)"""
# exported methods
__instance = DurableRulesEngine("http://localhost:8080")
def abandon_action(*args, **kwargs): # real signature unknown
pass
def assert_event(session_id, serialized_fact):
return __instance.
| 867
|
1,399
| 38
| 4,347
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/durable_rules_engine.py
|
infile
|
create_ruleset
| true
|
function
| 7
| 7
| false
| true
|
[
"assert_fact",
"get_facts",
"retract_fact",
"start_action_for_state",
"complete_and_start_action",
"__init__",
"assert_event",
"create_ruleset",
"__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_event",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "start_action_for_state",
"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 logging
import requests
_logger = logging.getLogger(__name__)
class DurableRulesEngine:
__host = None
__last_resp = None
def __init__(self, host):
self.__host = host
def create_ruleset(self, ruleset_name, ruleset_string): # real signature unknown
# {
# "sid": "0",
# "id": "sid-0",
# "$s": 1
# }
req = {ruleset_name: json.loads(ruleset_string)}
r = requests.post(self.__host + '/create-durable-rules-executor', json=req)
if r.status_code != 200:
raise Exception(f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
id = r.text
return id
def assert_event(self, session_id, serialized_fact):
_logger.warning("assert_event not yet implemented: using assert_fact")
return self.assert_fact(session_id, serialized_fact)
def assert_fact(self, session_id, serialized_fact):
d = json.loads(serialized_fact)
if 'j' in serialized_fact:
d['j'] = 1
serialized_fact = json.dumps(d)
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/process",
json=json.loads(serialized_fact))
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
self.__last_resp = r.json()
self.__last_resp.reverse()
# {
# "sid": "0",
# "id": "sid-0",
# "$s": 1
# }
return (0, session_id)
def start_action_for_state(self, handle): # real signature unknown
try:
resp = self.__last_resp.pop()
except:
return None
return ('{ "sid":"0", "id":"sid-0", "$s":1}', json.dumps(resp), handle)
def complete_and_start_action(self, handle): # real signature unknown
_logger.info("complete_and_start_action: %d", handle)
try:
resp = self.__last_resp.pop()
except:
return None
return json.dumps(resp)
def retract_fact(self, session_id, serialized_fact):
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/retract-fact",
json=json.loads(serialized_fact))
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
#self.__last_resp = r.json()
#self.__last_resp.reverse()
return (0, session_id)
def get_facts(self, session_id, _sid):
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/get-all-facts")
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
#self.__last_resp = r.json()
#self.__last_resp.reverse()
return r.content
class error(Exception):
# no doc
def __init__(self, *args, **kwargs): # real signature unknown
pass
__weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""list of weak references to the object (if defined)"""
# exported methods
__instance = DurableRulesEngine("http://localhost:8080")
def abandon_action(*args, **kwargs): # real signature unknown
pass
def assert_event(session_id, serialized_fact):
return __instance.assert_fact(session_id, serialized_fact)
def assert_events(*args, **kwargs): # real signature unknown
raise Exception("assert_events")
def assert_fact(session_id, serialized_fact):
return __instance.assert_fact(session_id, serialized_fact)
def assert_facts(*args, **kwargs): # real signature unknown
pass
def assert_timers(*args, **kwargs): # real signature unknown
pass
def cancel_timer(*args, **kwargs): # real signature unknown
pass
def complete_get_idle_state(*args, **kwargs): # real signature unknown
pass
def complete_get_queued_messages(*args, **kwargs): # real signature unknown
pass
def create_ruleset(ruleset_name, ruleset_string):
return __instance.
|
[
"assert_fact",
"get_facts",
"retract_fact",
"start_action_for_state",
"complete_and_start_action",
"assert_event",
"create_ruleset"
] |
us_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
#self.__last_resp = r.json()
#self.__last_resp.reverse()
return (0, session_id)
def get_facts(self, session_id, _sid):
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/get-all-facts")
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
#self.__last_resp = r.json()
#self.__last_resp.reverse()
return r.content
class error(Exception):
# no doc
def __init__(self, *args, **kwargs): # real signature unknown
pass
__weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""list of weak references to the object (if defined)"""
# exported methods
__instance = DurableRulesEngine("http://localhost:8080")
def abandon_action(*args, **kwargs): # real signature unknown
pass
def assert_event(session_id, serialized_fact):
return __instance.assert_fact(session_id, serialized_fact)
def assert_events(*args, **kwargs): # real signature unknown
raise Exception("assert_events")
def assert_fact(session_id, serialized_fact):
return __instance.assert_fact(session_id, serialized_fact)
def assert_facts(*args, **kwargs): # real signature unknown
pass
def assert_timers(*args, **kwargs): # real signature unknown
pass
def cancel_timer(*args, **kwargs): # real signature unknown
pass
def complete_get_idle_state(*args, **kwargs): # real signature unknown
pass
def complete_get_queued_messages(*args, **kwargs): # real signature unknown
pass
def create_ruleset(ruleset_name, ruleset_string):
return __instance.
| 869
|
1,400
| 38
| 4,794
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/durable_rules_engine.py
|
infile
|
get_facts
| true
|
function
| 7
| 7
| false
| true
|
[
"assert_fact",
"retract_fact",
"create_ruleset",
"start_action_for_state",
"complete_and_start_action",
"__init__",
"assert_event",
"get_facts",
"__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_event",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "start_action_for_state",
"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 logging
import requests
_logger = logging.getLogger(__name__)
class DurableRulesEngine:
__host = None
__last_resp = None
def __init__(self, host):
self.__host = host
def create_ruleset(self, ruleset_name, ruleset_string): # real signature unknown
# {
# "sid": "0",
# "id": "sid-0",
# "$s": 1
# }
req = {ruleset_name: json.loads(ruleset_string)}
r = requests.post(self.__host + '/create-durable-rules-executor', json=req)
if r.status_code != 200:
raise Exception(f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
id = r.text
return id
def assert_event(self, session_id, serialized_fact):
_logger.warning("assert_event not yet implemented: using assert_fact")
return self.assert_fact(session_id, serialized_fact)
def assert_fact(self, session_id, serialized_fact):
d = json.loads(serialized_fact)
if 'j' in serialized_fact:
d['j'] = 1
serialized_fact = json.dumps(d)
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/process",
json=json.loads(serialized_fact))
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
self.__last_resp = r.json()
self.__last_resp.reverse()
# {
# "sid": "0",
# "id": "sid-0",
# "$s": 1
# }
return (0, session_id)
def start_action_for_state(self, handle): # real signature unknown
try:
resp = self.__last_resp.pop()
except:
return None
return ('{ "sid":"0", "id":"sid-0", "$s":1}', json.dumps(resp), handle)
def complete_and_start_action(self, handle): # real signature unknown
_logger.info("complete_and_start_action: %d", handle)
try:
resp = self.__last_resp.pop()
except:
return None
return json.dumps(resp)
def retract_fact(self, session_id, serialized_fact):
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/retract-fact",
json=json.loads(serialized_fact))
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
#self.__last_resp = r.json()
#self.__last_resp.reverse()
return (0, session_id)
def get_facts(self, session_id, _sid):
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/get-all-facts")
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
#self.__last_resp = r.json()
#self.__last_resp.reverse()
return r.content
class error(Exception):
# no doc
def __init__(self, *args, **kwargs): # real signature unknown
pass
__weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""list of weak references to the object (if defined)"""
# exported methods
__instance = DurableRulesEngine("http://localhost:8080")
def abandon_action(*args, **kwargs): # real signature unknown
pass
def assert_event(session_id, serialized_fact):
return __instance.assert_fact(session_id, serialized_fact)
def assert_events(*args, **kwargs): # real signature unknown
raise Exception("assert_events")
def assert_fact(session_id, serialized_fact):
return __instance.assert_fact(session_id, serialized_fact)
def assert_facts(*args, **kwargs): # real signature unknown
pass
def assert_timers(*args, **kwargs): # real signature unknown
pass
def cancel_timer(*args, **kwargs): # real signature unknown
pass
def complete_get_idle_state(*args, **kwargs): # real signature unknown
pass
def complete_get_queued_messages(*args, **kwargs): # real signature unknown
pass
def create_ruleset(ruleset_name, ruleset_string):
return __instance.create_ruleset(ruleset_name, ruleset_string)
def delete_ruleset(*args, **kwargs): # real signature unknown
pass
def delete_state(*args, **kwargs): # real signature unknown
raise Exception("delete_state")
def get_events(*args, **kwargs): # real signature unknown
_logger.warning("get_events() not yet implemented. Ignoring.")
return "{}"
def get_facts(handle, session_id): # real signature unknown
return __instance.
|
[
"assert_fact",
"retract_fact",
"create_ruleset",
"start_action_for_state",
"complete_and_start_action",
"assert_event",
"get_facts"
] |
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
#self.__last_resp = r.json()
#self.__last_resp.reverse()
return r.content
class error(Exception):
# no doc
def __init__(self, *args, **kwargs): # real signature unknown
pass
__weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""list of weak references to the object (if defined)"""
# exported methods
__instance = DurableRulesEngine("http://localhost:8080")
def abandon_action(*args, **kwargs): # real signature unknown
pass
def assert_event(session_id, serialized_fact):
return __instance.assert_fact(session_id, serialized_fact)
def assert_events(*args, **kwargs): # real signature unknown
raise Exception("assert_events")
def assert_fact(session_id, serialized_fact):
return __instance.assert_fact(session_id, serialized_fact)
def assert_facts(*args, **kwargs): # real signature unknown
pass
def assert_timers(*args, **kwargs): # real signature unknown
pass
def cancel_timer(*args, **kwargs): # real signature unknown
pass
def complete_get_idle_state(*args, **kwargs): # real signature unknown
pass
def complete_get_queued_messages(*args, **kwargs): # real signature unknown
pass
def create_ruleset(ruleset_name, ruleset_string):
return __instance.create_ruleset(ruleset_name, ruleset_string)
def delete_ruleset(*args, **kwargs): # real signature unknown
pass
def delete_state(*args, **kwargs): # real signature unknown
raise Exception("delete_state")
def get_events(*args, **kwargs): # real signature unknown
_logger.warning("get_events() not yet implemented. Ignoring.")
return "{}"
def get_facts(handle, session_id): # real signature unknown
return __instance.
| 870
|
1,401
| 38
| 5,029
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/durable_rules_engine.py
|
infile
|
retract_fact
| true
|
function
| 7
| 7
| false
| true
|
[
"assert_fact",
"get_facts",
"create_ruleset",
"start_action_for_state",
"complete_and_start_action",
"__init__",
"assert_event",
"retract_fact",
"__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_event",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "start_action_for_state",
"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 logging
import requests
_logger = logging.getLogger(__name__)
class DurableRulesEngine:
__host = None
__last_resp = None
def __init__(self, host):
self.__host = host
def create_ruleset(self, ruleset_name, ruleset_string): # real signature unknown
# {
# "sid": "0",
# "id": "sid-0",
# "$s": 1
# }
req = {ruleset_name: json.loads(ruleset_string)}
r = requests.post(self.__host + '/create-durable-rules-executor', json=req)
if r.status_code != 200:
raise Exception(f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
id = r.text
return id
def assert_event(self, session_id, serialized_fact):
_logger.warning("assert_event not yet implemented: using assert_fact")
return self.assert_fact(session_id, serialized_fact)
def assert_fact(self, session_id, serialized_fact):
d = json.loads(serialized_fact)
if 'j' in serialized_fact:
d['j'] = 1
serialized_fact = json.dumps(d)
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/process",
json=json.loads(serialized_fact))
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
self.__last_resp = r.json()
self.__last_resp.reverse()
# {
# "sid": "0",
# "id": "sid-0",
# "$s": 1
# }
return (0, session_id)
def start_action_for_state(self, handle): # real signature unknown
try:
resp = self.__last_resp.pop()
except:
return None
return ('{ "sid":"0", "id":"sid-0", "$s":1}', json.dumps(resp), handle)
def complete_and_start_action(self, handle): # real signature unknown
_logger.info("complete_and_start_action: %d", handle)
try:
resp = self.__last_resp.pop()
except:
return None
return json.dumps(resp)
def retract_fact(self, session_id, serialized_fact):
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/retract-fact",
json=json.loads(serialized_fact))
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
#self.__last_resp = r.json()
#self.__last_resp.reverse()
return (0, session_id)
def get_facts(self, session_id, _sid):
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/get-all-facts")
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
#self.__last_resp = r.json()
#self.__last_resp.reverse()
return r.content
class error(Exception):
# no doc
def __init__(self, *args, **kwargs): # real signature unknown
pass
__weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""list of weak references to the object (if defined)"""
# exported methods
__instance = DurableRulesEngine("http://localhost:8080")
def abandon_action(*args, **kwargs): # real signature unknown
pass
def assert_event(session_id, serialized_fact):
return __instance.assert_fact(session_id, serialized_fact)
def assert_events(*args, **kwargs): # real signature unknown
raise Exception("assert_events")
def assert_fact(session_id, serialized_fact):
return __instance.assert_fact(session_id, serialized_fact)
def assert_facts(*args, **kwargs): # real signature unknown
pass
def assert_timers(*args, **kwargs): # real signature unknown
pass
def cancel_timer(*args, **kwargs): # real signature unknown
pass
def complete_get_idle_state(*args, **kwargs): # real signature unknown
pass
def complete_get_queued_messages(*args, **kwargs): # real signature unknown
pass
def create_ruleset(ruleset_name, ruleset_string):
return __instance.create_ruleset(ruleset_name, ruleset_string)
def delete_ruleset(*args, **kwargs): # real signature unknown
pass
def delete_state(*args, **kwargs): # real signature unknown
raise Exception("delete_state")
def get_events(*args, **kwargs): # real signature unknown
_logger.warning("get_events() not yet implemented. Ignoring.")
return "{}"
def get_facts(handle, session_id): # real signature unknown
return __instance.get_facts(handle, session_id)
def get_state(*args, **kwargs): # real signature unknown
pass
def renew_action_lease(*args, **kwargs): # real signature unknown
pass
def retract_fact(handle, payload):
return __instance.
|
[
"assert_fact",
"get_facts",
"create_ruleset",
"start_action_for_state",
"complete_and_start_action",
"assert_event",
"retract_fact"
] |
eturn r.content
class error(Exception):
# no doc
def __init__(self, *args, **kwargs): # real signature unknown
pass
__weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""list of weak references to the object (if defined)"""
# exported methods
__instance = DurableRulesEngine("http://localhost:8080")
def abandon_action(*args, **kwargs): # real signature unknown
pass
def assert_event(session_id, serialized_fact):
return __instance.assert_fact(session_id, serialized_fact)
def assert_events(*args, **kwargs): # real signature unknown
raise Exception("assert_events")
def assert_fact(session_id, serialized_fact):
return __instance.assert_fact(session_id, serialized_fact)
def assert_facts(*args, **kwargs): # real signature unknown
pass
def assert_timers(*args, **kwargs): # real signature unknown
pass
def cancel_timer(*args, **kwargs): # real signature unknown
pass
def complete_get_idle_state(*args, **kwargs): # real signature unknown
pass
def complete_get_queued_messages(*args, **kwargs): # real signature unknown
pass
def create_ruleset(ruleset_name, ruleset_string):
return __instance.create_ruleset(ruleset_name, ruleset_string)
def delete_ruleset(*args, **kwargs): # real signature unknown
pass
def delete_state(*args, **kwargs): # real signature unknown
raise Exception("delete_state")
def get_events(*args, **kwargs): # real signature unknown
_logger.warning("get_events() not yet implemented. Ignoring.")
return "{}"
def get_facts(handle, session_id): # real signature unknown
return __instance.get_facts(handle, session_id)
def get_state(*args, **kwargs): # real signature unknown
pass
def renew_action_lease(*args, **kwargs): # real signature unknown
pass
def retract_fact(handle, payload):
return __instance.
| 871
|
1,402
| 38
| 5,766
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/durable_rules_engine.py
|
infile
|
start_action_for_state
| true
|
function
| 7
| 7
| false
| true
|
[
"assert_fact",
"complete_and_start_action",
"get_facts",
"retract_fact",
"create_ruleset",
"__init__",
"assert_event",
"start_action_for_state",
"__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_event",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "start_action_for_state",
"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 logging
import requests
_logger = logging.getLogger(__name__)
class DurableRulesEngine:
__host = None
__last_resp = None
def __init__(self, host):
self.__host = host
def create_ruleset(self, ruleset_name, ruleset_string): # real signature unknown
# {
# "sid": "0",
# "id": "sid-0",
# "$s": 1
# }
req = {ruleset_name: json.loads(ruleset_string)}
r = requests.post(self.__host + '/create-durable-rules-executor', json=req)
if r.status_code != 200:
raise Exception(f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
id = r.text
return id
def assert_event(self, session_id, serialized_fact):
_logger.warning("assert_event not yet implemented: using assert_fact")
return self.assert_fact(session_id, serialized_fact)
def assert_fact(self, session_id, serialized_fact):
d = json.loads(serialized_fact)
if 'j' in serialized_fact:
d['j'] = 1
serialized_fact = json.dumps(d)
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/process",
json=json.loads(serialized_fact))
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
self.__last_resp = r.json()
self.__last_resp.reverse()
# {
# "sid": "0",
# "id": "sid-0",
# "$s": 1
# }
return (0, session_id)
def start_action_for_state(self, handle): # real signature unknown
try:
resp = self.__last_resp.pop()
except:
return None
return ('{ "sid":"0", "id":"sid-0", "$s":1}', json.dumps(resp), handle)
def complete_and_start_action(self, handle): # real signature unknown
_logger.info("complete_and_start_action: %d", handle)
try:
resp = self.__last_resp.pop()
except:
return None
return json.dumps(resp)
def retract_fact(self, session_id, serialized_fact):
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/retract-fact",
json=json.loads(serialized_fact))
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
#self.__last_resp = r.json()
#self.__last_resp.reverse()
return (0, session_id)
def get_facts(self, session_id, _sid):
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/get-all-facts")
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
#self.__last_resp = r.json()
#self.__last_resp.reverse()
return r.content
class error(Exception):
# no doc
def __init__(self, *args, **kwargs): # real signature unknown
pass
__weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""list of weak references to the object (if defined)"""
# exported methods
__instance = DurableRulesEngine("http://localhost:8080")
def abandon_action(*args, **kwargs): # real signature unknown
pass
def assert_event(session_id, serialized_fact):
return __instance.assert_fact(session_id, serialized_fact)
def assert_events(*args, **kwargs): # real signature unknown
raise Exception("assert_events")
def assert_fact(session_id, serialized_fact):
return __instance.assert_fact(session_id, serialized_fact)
def assert_facts(*args, **kwargs): # real signature unknown
pass
def assert_timers(*args, **kwargs): # real signature unknown
pass
def cancel_timer(*args, **kwargs): # real signature unknown
pass
def complete_get_idle_state(*args, **kwargs): # real signature unknown
pass
def complete_get_queued_messages(*args, **kwargs): # real signature unknown
pass
def create_ruleset(ruleset_name, ruleset_string):
return __instance.create_ruleset(ruleset_name, ruleset_string)
def delete_ruleset(*args, **kwargs): # real signature unknown
pass
def delete_state(*args, **kwargs): # real signature unknown
raise Exception("delete_state")
def get_events(*args, **kwargs): # real signature unknown
_logger.warning("get_events() not yet implemented. Ignoring.")
return "{}"
def get_facts(handle, session_id): # real signature unknown
return __instance.get_facts(handle, session_id)
def get_state(*args, **kwargs): # real signature unknown
pass
def renew_action_lease(*args, **kwargs): # real signature unknown
pass
def retract_fact(handle, payload):
return __instance.retract_fact(handle, payload)
def retract_facts(*args, **kwargs): # real signature unknown
pass
def set_delete_message_callback(*args, **kwargs): # real signature unknown
pass
def set_get_idle_state_callback(*args, **kwargs): # real signature unknown
pass
def set_get_queued_messages_callback(*args, **kwargs): # real signature unknown
pass
def set_queue_message_callback(*args, **kwargs): # real signature unknown
pass
def set_store_message_callback(*args, **kwargs): # real signature unknown
pass
def start_action(*args, **kwargs):
_logger.warning("start_action() not yet implemented. Ignoring.")
return None
def start_action_for_state(handle, state_handle):
return __instance.
|
[
"assert_fact",
"complete_and_start_action",
"get_facts",
"retract_fact",
"create_ruleset",
"assert_event",
"start_action_for_state"
] |
sert_fact(session_id, serialized_fact)
def assert_facts(*args, **kwargs): # real signature unknown
pass
def assert_timers(*args, **kwargs): # real signature unknown
pass
def cancel_timer(*args, **kwargs): # real signature unknown
pass
def complete_get_idle_state(*args, **kwargs): # real signature unknown
pass
def complete_get_queued_messages(*args, **kwargs): # real signature unknown
pass
def create_ruleset(ruleset_name, ruleset_string):
return __instance.create_ruleset(ruleset_name, ruleset_string)
def delete_ruleset(*args, **kwargs): # real signature unknown
pass
def delete_state(*args, **kwargs): # real signature unknown
raise Exception("delete_state")
def get_events(*args, **kwargs): # real signature unknown
_logger.warning("get_events() not yet implemented. Ignoring.")
return "{}"
def get_facts(handle, session_id): # real signature unknown
return __instance.get_facts(handle, session_id)
def get_state(*args, **kwargs): # real signature unknown
pass
def renew_action_lease(*args, **kwargs): # real signature unknown
pass
def retract_fact(handle, payload):
return __instance.retract_fact(handle, payload)
def retract_facts(*args, **kwargs): # real signature unknown
pass
def set_delete_message_callback(*args, **kwargs): # real signature unknown
pass
def set_get_idle_state_callback(*args, **kwargs): # real signature unknown
pass
def set_get_queued_messages_callback(*args, **kwargs): # real signature unknown
pass
def set_queue_message_callback(*args, **kwargs): # real signature unknown
pass
def set_store_message_callback(*args, **kwargs): # real signature unknown
pass
def start_action(*args, **kwargs):
_logger.warning("start_action() not yet implemented. Ignoring.")
return None
def start_action_for_state(handle, state_handle):
return __instance.
| 872
|
1,403
| 38
| 5,876
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/durable_rules_engine.py
|
infile
|
complete_and_start_action
| true
|
function
| 7
| 7
| false
| true
|
[
"assert_fact",
"start_action_for_state",
"get_facts",
"retract_fact",
"create_ruleset",
"__init__",
"assert_event",
"complete_and_start_action",
"__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_event",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "start_action_for_state",
"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 logging
import requests
_logger = logging.getLogger(__name__)
class DurableRulesEngine:
__host = None
__last_resp = None
def __init__(self, host):
self.__host = host
def create_ruleset(self, ruleset_name, ruleset_string): # real signature unknown
# {
# "sid": "0",
# "id": "sid-0",
# "$s": 1
# }
req = {ruleset_name: json.loads(ruleset_string)}
r = requests.post(self.__host + '/create-durable-rules-executor', json=req)
if r.status_code != 200:
raise Exception(f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
id = r.text
return id
def assert_event(self, session_id, serialized_fact):
_logger.warning("assert_event not yet implemented: using assert_fact")
return self.assert_fact(session_id, serialized_fact)
def assert_fact(self, session_id, serialized_fact):
d = json.loads(serialized_fact)
if 'j' in serialized_fact:
d['j'] = 1
serialized_fact = json.dumps(d)
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/process",
json=json.loads(serialized_fact))
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
self.__last_resp = r.json()
self.__last_resp.reverse()
# {
# "sid": "0",
# "id": "sid-0",
# "$s": 1
# }
return (0, session_id)
def start_action_for_state(self, handle): # real signature unknown
try:
resp = self.__last_resp.pop()
except:
return None
return ('{ "sid":"0", "id":"sid-0", "$s":1}', json.dumps(resp), handle)
def complete_and_start_action(self, handle): # real signature unknown
_logger.info("complete_and_start_action: %d", handle)
try:
resp = self.__last_resp.pop()
except:
return None
return json.dumps(resp)
def retract_fact(self, session_id, serialized_fact):
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/retract-fact",
json=json.loads(serialized_fact))
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
#self.__last_resp = r.json()
#self.__last_resp.reverse()
return (0, session_id)
def get_facts(self, session_id, _sid):
r = requests.post(f"{self.__host}/rules-durable-executors/{session_id}/get-all-facts")
if r.status_code != 200:
raise Exception(
f"Invalid status code: {r.status_code} - {r.reason}\n"
+ json.loads(r.content)['details'])
#self.__last_resp = r.json()
#self.__last_resp.reverse()
return r.content
class error(Exception):
# no doc
def __init__(self, *args, **kwargs): # real signature unknown
pass
__weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""list of weak references to the object (if defined)"""
# exported methods
__instance = DurableRulesEngine("http://localhost:8080")
def abandon_action(*args, **kwargs): # real signature unknown
pass
def assert_event(session_id, serialized_fact):
return __instance.assert_fact(session_id, serialized_fact)
def assert_events(*args, **kwargs): # real signature unknown
raise Exception("assert_events")
def assert_fact(session_id, serialized_fact):
return __instance.assert_fact(session_id, serialized_fact)
def assert_facts(*args, **kwargs): # real signature unknown
pass
def assert_timers(*args, **kwargs): # real signature unknown
pass
def cancel_timer(*args, **kwargs): # real signature unknown
pass
def complete_get_idle_state(*args, **kwargs): # real signature unknown
pass
def complete_get_queued_messages(*args, **kwargs): # real signature unknown
pass
def create_ruleset(ruleset_name, ruleset_string):
return __instance.create_ruleset(ruleset_name, ruleset_string)
def delete_ruleset(*args, **kwargs): # real signature unknown
pass
def delete_state(*args, **kwargs): # real signature unknown
raise Exception("delete_state")
def get_events(*args, **kwargs): # real signature unknown
_logger.warning("get_events() not yet implemented. Ignoring.")
return "{}"
def get_facts(handle, session_id): # real signature unknown
return __instance.get_facts(handle, session_id)
def get_state(*args, **kwargs): # real signature unknown
pass
def renew_action_lease(*args, **kwargs): # real signature unknown
pass
def retract_fact(handle, payload):
return __instance.retract_fact(handle, payload)
def retract_facts(*args, **kwargs): # real signature unknown
pass
def set_delete_message_callback(*args, **kwargs): # real signature unknown
pass
def set_get_idle_state_callback(*args, **kwargs): # real signature unknown
pass
def set_get_queued_messages_callback(*args, **kwargs): # real signature unknown
pass
def set_queue_message_callback(*args, **kwargs): # real signature unknown
pass
def set_store_message_callback(*args, **kwargs): # real signature unknown
pass
def start_action(*args, **kwargs):
_logger.warning("start_action() not yet implemented. Ignoring.")
return None
def start_action_for_state(handle, state_handle):
return __instance.start_action_for_state(handle)
def complete_and_start_action(handle, context_handle):
return __instance.
|
[
"assert_fact",
"start_action_for_state",
"get_facts",
"retract_fact",
"create_ruleset",
"assert_event",
"complete_and_start_action"
] |
def assert_timers(*args, **kwargs): # real signature unknown
pass
def cancel_timer(*args, **kwargs): # real signature unknown
pass
def complete_get_idle_state(*args, **kwargs): # real signature unknown
pass
def complete_get_queued_messages(*args, **kwargs): # real signature unknown
pass
def create_ruleset(ruleset_name, ruleset_string):
return __instance.create_ruleset(ruleset_name, ruleset_string)
def delete_ruleset(*args, **kwargs): # real signature unknown
pass
def delete_state(*args, **kwargs): # real signature unknown
raise Exception("delete_state")
def get_events(*args, **kwargs): # real signature unknown
_logger.warning("get_events() not yet implemented. Ignoring.")
return "{}"
def get_facts(handle, session_id): # real signature unknown
return __instance.get_facts(handle, session_id)
def get_state(*args, **kwargs): # real signature unknown
pass
def renew_action_lease(*args, **kwargs): # real signature unknown
pass
def retract_fact(handle, payload):
return __instance.retract_fact(handle, payload)
def retract_facts(*args, **kwargs): # real signature unknown
pass
def set_delete_message_callback(*args, **kwargs): # real signature unknown
pass
def set_get_idle_state_callback(*args, **kwargs): # real signature unknown
pass
def set_get_queued_messages_callback(*args, **kwargs): # real signature unknown
pass
def set_queue_message_callback(*args, **kwargs): # real signature unknown
pass
def set_store_message_callback(*args, **kwargs): # real signature unknown
pass
def start_action(*args, **kwargs):
_logger.warning("start_action() not yet implemented. Ignoring.")
return None
def start_action_for_state(handle, state_handle):
return __instance.start_action_for_state(handle)
def complete_and_start_action(handle, context_handle):
return __instance.
| 873
|
1,428
| 39
| 2,645
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
host
| true
|
statement
| 20
| 20
| false
| false
|
[
"s",
"host",
"assert_fact",
"get_facts",
"_handle",
"__getattr__",
"__init__",
"_completed",
"_deleted",
"_has_completed",
"_is_deleted",
"_m",
"_ruleset",
"_start_time",
"cancel_timer",
"delete_state",
"get_pending_events",
"m",
"post",
"renew_action_lease",
"retract_fact",
"start_timer",
"__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": "cancel_timer",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "host",
"type": "statement"
},
{
"name": "m",
"type": "statement"
},
{
"name": "post",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "s",
"type": "statement"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "_completed",
"type": "statement"
},
{
"name": "_deleted",
"type": "statement"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_has_completed",
"type": "function"
},
{
"name": "_is_deleted",
"type": "function"
},
{
"name": "_m",
"type": "statement"
},
{
"name": "_ruleset",
"type": "statement"
},
{
"name": "_start_time",
"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": "__getattr__",
"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 copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.
|
[
"s",
"host",
"assert_fact",
"get_facts",
"cancel_timer",
"delete_state",
"get_pending_events",
"m",
"post",
"renew_action_lease",
"retract_fact",
"start_timer"
] |
ure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.
| 885
|
1,429
| 39
| 2,650
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
retract_fact
| true
|
function
| 38
| 37
| false
| true
|
[
"assert_fact",
"get_action",
"get_facts",
"assert_facts",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_directory",
"_ruleset_list",
"_run",
"_t_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"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",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__",
"assert_event"
] |
[
{
"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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.
|
[
"assert_fact",
"get_action",
"get_facts",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"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",
"assert_event"
] |
bject):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.
| 886
|
1,443
| 39
| 3,352
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
s
| true
|
statement
| 20
| 20
| false
| false
|
[
"s",
"_start_time",
"renew_action_lease",
"host",
"_ruleset",
"__getattr__",
"__init__",
"_completed",
"_deleted",
"_handle",
"_has_completed",
"_is_deleted",
"_m",
"assert_fact",
"cancel_timer",
"delete_state",
"get_facts",
"get_pending_events",
"m",
"post",
"retract_fact",
"start_timer",
"__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": "cancel_timer",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "host",
"type": "statement"
},
{
"name": "m",
"type": "statement"
},
{
"name": "post",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "s",
"type": "statement"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "_completed",
"type": "statement"
},
{
"name": "_deleted",
"type": "statement"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_has_completed",
"type": "function"
},
{
"name": "_is_deleted",
"type": "function"
},
{
"name": "_m",
"type": "statement"
},
{
"name": "_ruleset",
"type": "statement"
},
{
"name": "_start_time",
"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": "__getattr__",
"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 copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.
|
[
"s",
"renew_action_lease",
"host",
"assert_fact",
"cancel_timer",
"delete_state",
"get_facts",
"get_pending_events",
"m",
"post",
"retract_fact",
"start_timer"
] |
in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.
| 895
|
1,447
| 39
| 3,487
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
s
| true
|
statement
| 20
| 20
| false
| false
|
[
"assert_fact",
"retract_fact",
"get_facts",
"s",
"_ruleset",
"__getattr__",
"__init__",
"_completed",
"_deleted",
"_handle",
"_has_completed",
"_is_deleted",
"_m",
"_start_time",
"cancel_timer",
"delete_state",
"get_pending_events",
"host",
"m",
"post",
"renew_action_lease",
"start_timer",
"__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": "cancel_timer",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "host",
"type": "statement"
},
{
"name": "m",
"type": "statement"
},
{
"name": "post",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "s",
"type": "statement"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "_completed",
"type": "statement"
},
{
"name": "_deleted",
"type": "statement"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_has_completed",
"type": "function"
},
{
"name": "_is_deleted",
"type": "function"
},
{
"name": "_m",
"type": "statement"
},
{
"name": "_ruleset",
"type": "statement"
},
{
"name": "_start_time",
"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": "__getattr__",
"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 copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.
|
[
"assert_fact",
"retract_fact",
"get_facts",
"s",
"cancel_timer",
"delete_state",
"get_pending_events",
"host",
"m",
"post",
"renew_action_lease",
"start_timer"
] |
e._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.
| 897
|
1,488
| 39
| 6,627
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
run
| true
|
function
| 2
| 7
| false
| true
|
[
"run",
"root"
] |
[
{
"name": "continue_with",
"type": "function"
},
{
"name": "root",
"type": "statement"
},
{
"name": "run",
"type": "function"
},
{
"name": "_func",
"type": "statement"
},
{
"name": "_next",
"type": "statement"
},
{
"name": "_sync",
"type": "statement"
},
{
"name": "_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__bool__",
"type": "instance"
},
{
"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": "__ge__",
"type": "instance"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "instance"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "instance"
},
{
"name": "__lt__",
"type": "instance"
},
{
"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"
},
{
"name": "__subclasshook__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.
|
[
"run",
"root"
] |
):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.
| 924
|
1,518
| 39
| 9,216
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
create_ruleset
| true
|
function
| 32
| 35
| false
| true
|
[
"get_facts",
"start_action",
"update_state",
"abandon_action",
"start_action_for_state",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"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_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.
|
[
"get_facts",
"start_action",
"update_state",
"abandon_action",
"start_action_for_state",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer"
] |
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.
| 944
|
1,533
| 39
| 10,475
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
retract_fact
| true
|
function
| 32
| 35
| false
| false
|
[
"assert_fact",
"retract_facts",
"retract_fact",
"assert_facts",
"get_facts",
"abandon_action",
"assert_event",
"assert_events",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"start_timer",
"update_state",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"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_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.
|
[
"assert_fact",
"retract_facts",
"retract_fact",
"assert_facts",
"get_facts",
"abandon_action",
"assert_event",
"assert_events",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"start_timer",
"update_state"
] |
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.
| 958
|
1,536
| 39
| 10,653
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
retract_facts
| true
|
function
| 32
| 35
| false
| true
|
[
"retract_fact",
"assert_fact",
"assert_facts",
"get_facts",
"assert_event",
"abandon_action",
"assert_events",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"start_timer",
"update_state",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"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_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.
|
[
"retract_fact",
"assert_fact",
"assert_facts",
"get_facts",
"assert_event",
"abandon_action",
"assert_events",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"start_timer",
"update_state"
] |
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.
| 961
|
1,542
| 39
| 11,214
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
update_state
| true
|
function
| 32
| 35
| false
| true
|
[
"update_state",
"assert_timers",
"get_state",
"delete_state",
"abandon_action",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"start_timer",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"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_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.
|
[
"update_state",
"assert_timers",
"get_state",
"delete_state",
"abandon_action",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"start_timer"
] |
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.
| 967
|
1,548
| 39
| 11,708
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
renew_action_lease
| true
|
function
| 32
| 35
| false
| true
|
[
"abandon_action",
"renew_action_lease",
"delete_state",
"start_timer",
"cancel_timer",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"get_state",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"update_state",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"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_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.
|
[
"abandon_action",
"renew_action_lease",
"delete_state",
"start_timer",
"cancel_timer",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"get_state",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"update_state"
] |
False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.
| 973
|
1,550
| 39
| 11,866
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
get_facts
| true
|
function
| 32
| 35
| false
| true
|
[
"assert_fact",
"retract_fact",
"get_facts",
"assert_facts",
"retract_facts",
"abandon_action",
"assert_event",
"assert_events",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"start_timer",
"update_state",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"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_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.
|
[
"assert_fact",
"retract_fact",
"get_facts",
"assert_facts",
"retract_facts",
"abandon_action",
"assert_event",
"assert_events",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"start_timer",
"update_state"
] |
n.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.
| 975
|
1,552
| 39
| 12,067
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
get_events
| true
|
function
| 32
| 35
| false
| true
|
[
"assert_event",
"assert_events",
"get_state",
"assert_fact",
"retract_fact",
"abandon_action",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"renew_action_lease",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"start_timer",
"update_state",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"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_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.
|
[
"assert_event",
"assert_events",
"get_state",
"assert_fact",
"retract_fact",
"abandon_action",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"renew_action_lease",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"start_timer",
"update_state"
] |
)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.
| 977
|
1,561
| 39
| 12,696
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
set_get_queued_messages_callback
| true
|
function
| 32
| 35
| false
| true
|
[
"set_queue_message_callback",
"set_store_message_callback",
"set_delete_message_callback",
"set_get_idle_state_callback",
"abandon_action",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_get_queued_messages_callback",
"start_action",
"start_action_for_state",
"start_timer",
"update_state",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"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_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.
|
[
"set_queue_message_callback",
"set_store_message_callback",
"set_delete_message_callback",
"set_get_idle_state_callback",
"abandon_action",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_get_queued_messages_callback",
"start_action",
"start_action_for_state",
"start_timer",
"update_state"
] |
ation, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.
| 986
|
1,563
| 39
| 12,897
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
complete_get_queued_messages
| true
|
function
| 32
| 35
| false
| true
|
[
"abandon_action",
"complete_get_idle_state",
"delete_state",
"start_timer",
"cancel_timer",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"complete_and_start_action",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"update_state",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"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_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.
|
[
"abandon_action",
"complete_get_idle_state",
"delete_state",
"start_timer",
"cancel_timer",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"complete_and_start_action",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"update_state"
] |
d, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.
| 988
|
1,567
| 39
| 13,232
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
complete_get_idle_state
| true
|
function
| 32
| 35
| false
| true
|
[
"delete_state",
"get_state",
"abandon_action",
"complete_get_queued_messages",
"update_state",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"create_ruleset",
"delete_ruleset",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"start_timer",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"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_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.
|
[
"delete_state",
"get_state",
"abandon_action",
"complete_get_queued_messages",
"update_state",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"create_ruleset",
"delete_ruleset",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"start_timer"
] |
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.
| 992
|
1,570
| 39
| 14,008
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
assert_timers
| true
|
function
| 32
| 35
| false
| true
|
[
"update_state",
"start_timer",
"cancel_timer",
"assert_fact",
"retract_fact",
"abandon_action",
"assert_event",
"assert_events",
"assert_facts",
"assert_timers",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"get_state",
"renew_action_lease",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"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_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.
|
[
"update_state",
"start_timer",
"cancel_timer",
"assert_fact",
"retract_fact",
"abandon_action",
"assert_event",
"assert_events",
"assert_facts",
"assert_timers",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"get_state",
"renew_action_lease",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state"
] |
le, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.
| 995
|
1,582
| 39
| 15,101
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
complete_and_start_action
| true
|
function
| 32
| 35
| false
| true
|
[
"update_state",
"start_action",
"abandon_action",
"get_facts",
"create_ruleset",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action_for_state",
"start_timer",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"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_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.
|
[
"update_state",
"start_action",
"abandon_action",
"get_facts",
"create_ruleset",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action_for_state",
"start_timer"
] |
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.
| 1,004
|
1,587
| 39
| 15,749
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
abandon_action
| true
|
function
| 32
| 35
| false
| false
|
[
"abandon_action",
"renew_action_lease",
"delete_state",
"start_timer",
"cancel_timer",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"get_state",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"update_state",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"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_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.
|
[
"abandon_action",
"renew_action_lease",
"delete_state",
"start_timer",
"cancel_timer",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"get_state",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"update_state"
] |
n)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.
| 1,007
|
1,597
| 39
| 16,579
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
start_action_for_state
| true
|
function
| 32
| 35
| false
| true
|
[
"start_action",
"update_state",
"abandon_action",
"get_facts",
"create_ruleset",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action_for_state",
"start_timer",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"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_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.
|
[
"start_action",
"update_state",
"abandon_action",
"get_facts",
"create_ruleset",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action_for_state",
"start_timer"
] |
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.
| 1,014
|
1,600
| 39
| 17,022
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
start_action
| true
|
function
| 32
| 35
| false
| true
|
[
"get_facts",
"create_ruleset",
"update_state",
"assert_fact",
"retract_fact",
"abandon_action",
"assert_event",
"assert_events",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"start_timer",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"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_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.
|
[
"get_facts",
"create_ruleset",
"update_state",
"assert_fact",
"retract_fact",
"abandon_action",
"assert_event",
"assert_events",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"start_timer"
] |
omplete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.
| 1,017
|
1,647
| 39
| 31,369
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
get_ruleset
| true
|
function
| 37
| 37
| false
| false
|
[
"get_ruleset",
"_ruleset_list",
"load_ruleset",
"get_idle_state_callback",
"delete_state",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_directory",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"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",
"__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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.
|
[
"get_ruleset",
"load_ruleset",
"get_idle_state_callback",
"delete_state",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"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"
] |
n(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.
| 1,049
|
1,650
| 39
| 31,646
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
get_ruleset
| true
|
function
| 37
| 37
| false
| false
|
[
"get_ruleset",
"_ruleset_directory",
"delete_message_callback",
"get_idle_state_callback",
"_ruleset_list",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"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",
"__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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.
|
[
"get_ruleset",
"delete_message_callback",
"get_idle_state_callback",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"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"
] |
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.
| 1,052
|
1,651
| 39
| 31,762
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
get_ruleset
| true
|
function
| 37
| 37
| false
| false
|
[
"get_ruleset",
"_ruleset_directory",
"_ruleset_list",
"register_rulesets",
"get_action",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"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",
"__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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.
|
[
"get_ruleset",
"register_rulesets",
"get_action",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"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"
] |
(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.
| 1,053
|
1,653
| 39
| 32,002
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
get_ruleset
| true
|
function
| 37
| 37
| false
| false
|
[
"get_ruleset",
"_ruleset_directory",
"_handle_function",
"_ruleset_list",
"get_idle_state_callback",
"__init__",
"_d_timer",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"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",
"__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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.
|
[
"get_ruleset",
"get_idle_state_callback",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"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"
] |
, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.
| 1,055
|
1,662
| 39
| 32,923
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
get_ruleset
| true
|
function
| 37
| 37
| false
| false
|
[
"get_queued_messages_callback",
"get_ruleset",
"_ruleset_directory",
"queue_message_callback",
"store_message_callback",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_list",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"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_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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",
"update_state",
"__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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.
|
[
"get_queued_messages_callback",
"get_ruleset",
"queue_message_callback",
"store_message_callback",
"assert_fact",
"assert_facts",
"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_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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",
"update_state"
] |
ame)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.
| 1,060
|
1,665
| 39
| 33,281
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
get_ruleset
| true
|
function
| 37
| 37
| false
| false
|
[
"get_idle_state_callback",
"get_ruleset",
"_ruleset_directory",
"register_rulesets",
"delete_state",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_list",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"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",
"__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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.
|
[
"get_idle_state_callback",
"get_ruleset",
"register_rulesets",
"delete_state",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"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"
] |
= self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.
| 1,062
|
1,670
| 39
| 33,844
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
inproject
|
store_message_callback
| true
|
statement
| 37
| 37
| false
| true
|
[
"_ruleset_list",
"_ruleset_directory",
"get_ruleset",
"queue_message_callback",
"delete_message_callback",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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",
"__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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.
|
[
"get_ruleset",
"queue_message_callback",
"delete_message_callback",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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"
] |
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.
| 1,067
|
1,671
| 39
| 33,928
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
store_message_callback
| true
|
statement
| 37
| 37
| false
| false
|
[
"_ruleset_list",
"queue_message_callback",
"delete_message_callback",
"get_queued_messages_callback",
"_ruleset_directory",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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",
"__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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.
|
[
"queue_message_callback",
"delete_message_callback",
"get_queued_messages_callback",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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"
] |
leset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.
| 1,068
|
1,672
| 39
| 33,977
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
inproject
|
delete_message_callback
| true
|
statement
| 37
| 37
| false
| true
|
[
"_ruleset_list",
"_ruleset_directory",
"store_message_callback",
"get_ruleset",
"queue_message_callback",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"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_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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",
"update_state",
"__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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.
|
[
"store_message_callback",
"get_ruleset",
"queue_message_callback",
"assert_fact",
"assert_facts",
"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_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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",
"update_state"
] |
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.
| 1,069
|
1,673
| 39
| 34,063
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
delete_message_callback
| true
|
statement
| 37
| 37
| false
| false
|
[
"_ruleset_list",
"queue_message_callback",
"store_message_callback",
"get_queued_messages_callback",
"_ruleset_directory",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"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_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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",
"update_state",
"__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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.
|
[
"queue_message_callback",
"store_message_callback",
"get_queued_messages_callback",
"assert_fact",
"assert_facts",
"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_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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",
"update_state"
] |
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.
| 1,070
|
1,674
| 39
| 34,113
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
inproject
|
queue_message_callback
| true
|
statement
| 37
| 37
| false
| true
|
[
"_ruleset_list",
"_ruleset_directory",
"store_message_callback",
"get_ruleset",
"delete_message_callback",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"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",
"update_state",
"__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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.
|
[
"store_message_callback",
"get_ruleset",
"delete_message_callback",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"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",
"update_state"
] |
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.
| 1,071
|
1,675
| 39
| 34,197
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
queue_message_callback
| true
|
statement
| 37
| 37
| false
| false
|
[
"_ruleset_list",
"store_message_callback",
"delete_message_callback",
"get_queued_messages_callback",
"_ruleset_directory",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"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",
"update_state",
"__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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.
|
[
"store_message_callback",
"delete_message_callback",
"get_queued_messages_callback",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"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",
"update_state"
] |
(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.
| 1,072
|
1,677
| 39
| 34,342
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
get_stored_messages_callback
| true
|
statement
| 37
| 37
| false
| false
|
[
"_ruleset_list",
"get_ruleset",
"store_message_callback",
"queue_message_callback",
"delete_message_callback",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_directory",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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",
"update_state",
"__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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.
|
[
"get_ruleset",
"store_message_callback",
"queue_message_callback",
"delete_message_callback",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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",
"update_state"
] |
back(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.
| 1,074
|
1,678
| 39
| 34,397
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
inproject
|
get_queued_messages_callback
| true
|
statement
| 37
| 37
| false
| true
|
[
"_ruleset_list",
"_ruleset_directory",
"queue_message_callback",
"store_message_callback",
"get_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"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_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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",
"update_state",
"__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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.
|
[
"queue_message_callback",
"store_message_callback",
"get_ruleset",
"assert_fact",
"assert_facts",
"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_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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",
"update_state"
] |
nc):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.
| 1,075
|
1,679
| 39
| 34,493
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
get_queued_messages_callback
| true
|
statement
| 37
| 37
| false
| false
|
[
"_ruleset_list",
"get_ruleset",
"queue_message_callback",
"store_message_callback",
"delete_message_callback",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_directory",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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",
"update_state",
"__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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.
|
[
"get_ruleset",
"queue_message_callback",
"store_message_callback",
"delete_message_callback",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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",
"update_state"
] |
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.
| 1,076
|
1,680
| 39
| 34,548
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
inproject
|
get_idle_state_callback
| true
|
statement
| 37
| 37
| false
| true
|
[
"_ruleset_list",
"_ruleset_directory",
"queue_message_callback",
"store_message_callback",
"get_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"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_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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",
"update_state",
"__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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.
|
[
"queue_message_callback",
"store_message_callback",
"get_ruleset",
"assert_fact",
"assert_facts",
"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_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"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",
"update_state"
] |
ef set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.
| 1,077
|
1,681
| 39
| 34,634
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
get_idle_state_callback
| true
|
statement
| 37
| 37
| false
| false
|
[
"_ruleset_list",
"get_ruleset",
"_ruleset_directory",
"get_idle_state_callback",
"load_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"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",
"__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"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.
|
[
"get_ruleset",
"get_idle_state_callback",
"load_ruleset",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"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"
] |
back = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.
| 1,078
|
1,768
| 40
| 3,554
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
infile
|
alias
| true
|
statement
| 10
| 10
| false
| false
|
[
"alias",
"_left",
"_op",
"_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",
"allItems",
"anyItem",
"define",
"imatches",
"matches"
] |
__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.
| 1,144
|
1,777
| 40
| 3,852
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
infile
|
alias
| true
|
statement
| 10
| 10
| false
| false
|
[
"alias",
"_left",
"_op",
"_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",
"allItems",
"anyItem",
"define",
"imatches",
"matches"
] |
eturn 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.
| 1,153
|
1,783
| 40
| 4,051
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
infile
|
alias
| true
|
statement
| 10
| 10
| false
| false
|
[
"alias",
"_left",
"_op",
"_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",
"allItems",
"anyItem",
"define",
"imatches",
"matches"
] |
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.
| 1,159
|
1,792
| 40
| 4,361
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
infile
|
alias
| true
|
statement
| 10
| 10
| false
| false
|
[
"alias",
"_left",
"_op",
"_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",
"allItems",
"anyItem",
"define",
"imatches",
"matches"
] |
, 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.
| 1,168
|
1,794
| 40
| 4,458
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
infile
|
alias
| true
|
statement
| 10
| 10
| false
| false
|
[
"alias",
"_left",
"_op",
"_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",
"allItems",
"anyItem",
"define",
"imatches",
"matches"
] |
ition = {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.
| 1,170
|
1,796
| 40
| 4,557
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
infile
|
alias
| true
|
statement
| 10
| 10
| false
| false
|
[
"alias",
"_left",
"_op",
"_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",
"allItems",
"anyItem",
"define",
"imatches",
"matches"
] |
ce(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.
| 1,172
|
1,812
| 40
| 5,340
|
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
infile
|
alias
| true
|
statement
| 10
| 10
| false
| false
|
[
"_type",
"_left",
"_op",
"alias",
"_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",
"allItems",
"anyItem",
"define",
"imatches",
"matches"
] |
f._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.
| 1,188
|
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.
|
[
"expression",
"define",
"func",
"alias",
"operator",
"cap",
"count",
"dist",
"multi",
"pri",
"for"
] |
_(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,223
|
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.
|
[
"expression",
"func",
"operator",
"alias",
"cap",
"count",
"define",
"dist",
"multi",
"pri",
"for"
] |
_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,224
|
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.
|
[
"func",
"dist",
"cap",
"pri",
"alias",
"count",
"define",
"expression",
"multi",
"operator"
] |
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,227
|
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.
|
[
"expression",
"count",
"func",
"alias",
"define",
"cap",
"dist",
"multi",
"operator",
"pri"
] |
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,228
|
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.
|
[
"func",
"dist",
"count",
"cap",
"alias",
"define",
"expression",
"multi",
"operator",
"pri"
] |
e = 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,229
|
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.
|
[
"func",
"pri",
"dist",
"count",
"alias",
"cap",
"define",
"expression",
"multi",
"operator"
] |
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,231
|
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.
|
[
"rules",
"name",
"define"
] |
fined_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,241
|
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.
|
[
"state_name",
"func",
"rule",
"define",
"when_any",
"when_all"
] |
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,243
|
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.
|
[
"func",
"rule",
"state_name",
"define",
"when_all",
"when_any"
] |
instance(_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,245
|
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.
|
[
"Host",
"logger",
"durable_rules_engine",
"Ruleset",
"To",
"Closure",
"Content",
"Flowchart",
"MessageNotHandledException",
"MessageObservedException",
"Promise",
"Statechart"
] |
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,268
|
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.
|
[
"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"
] |
witch_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,269
|
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().
|
[
"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"
] |
w_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,270
|
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().
|
[
"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"
] |
ine(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,274
|
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().
|
[
"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"
] |
value('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,277
|
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.
|
[
"stage_file",
"source_file",
"update_report",
"stage_file_obj",
"content",
"console",
"copy_report",
"execute_custom_assertions",
"name",
"refine_ydata_result",
"run",
"tests"
] |
t):
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,294
|
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.
|
[
"stage_file",
"console",
"name",
"source_file",
"content",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"stage_file_obj",
"tests",
"update_report"
] |
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,295
|
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.
|
[
"df",
"tests",
"df_type",
"label",
"dtypes",
"evaluate",
"get_warnings",
"random_state",
"store_warning"
] |
e(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,297
|
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.
|
[
"stage_file",
"source_file",
"content",
"name",
"copy_report",
"console",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"stage_file_obj",
"tests",
"update_report"
] |
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.
| 1,299
|
1,991
| 41
| 4,391
|
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
inproject
|
execute_and_remove_from_queue
| true
|
function
| 8
| 8
| false
| true
|
[
"stage_file",
"test_definition",
"function_name",
"stage_name",
"assertion",
"dataframe_from_source",
"execute_and_remove_from_queue",
"key",
"__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": "assertion",
"type": "statement"
},
{
"name": "dataframe_from_source",
"type": "function"
},
{
"name": "execute_and_remove_from_queue",
"type": "function"
},
{
"name": "function_name",
"type": "statement"
},
{
"name": "key",
"type": "function"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stage_name",
"type": "statement"
},
{
"name": "test_definition",
"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.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.refine_ydata_result(results)
fh.write(json.dumps(outputs))
self._show_result()
return outputs['has_error'], {'ge': ge_report_file, 'ydata': ydata_report_file}
except Exception as e:
# mark as error
self.console.print_exception(show_locals=True)
self._show_result(e)
return True, None
def copy_report(self, ge_workspace):
for report_json in glob(os.path.join(ge_workspace, 'great_expectations', 'uncommitted', '**', '*.json'),
recursive=True):
filename = os.path.basename(self.stage_file).split('.')[0]
report_name = f'{filename}_{self.name}_{os.path.basename(report_json)}'
shutil.copy(report_json, os.path.join(os.environ['PIPERIDER_REPORT_DIR'], report_name))
return report_name
def execute_custom_assertions(self, ge_context, report_file):
from piperider_cli.data.convert_to_exp import get_scheduled_tests
scheduled_tests = get_scheduled_tests()
if not scheduled_tests:
return
print(f"executing {len(scheduled_tests)} scheduled tests", )
for k, v in scheduled_tests.items():
try:
# execute the scheduled test
action_result = v.
|
[
"stage_file",
"test_definition",
"function_name",
"stage_name",
"assertion",
"dataframe_from_source",
"execute_and_remove_from_queue",
"key"
] |
xpectationsReporter()
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.refine_ydata_result(results)
fh.write(json.dumps(outputs))
self._show_result()
return outputs['has_error'], {'ge': ge_report_file, 'ydata': ydata_report_file}
except Exception as e:
# mark as error
self.console.print_exception(show_locals=True)
self._show_result(e)
return True, None
def copy_report(self, ge_workspace):
for report_json in glob(os.path.join(ge_workspace, 'great_expectations', 'uncommitted', '**', '*.json'),
recursive=True):
filename = os.path.basename(self.stage_file).split('.')[0]
report_name = f'{filename}_{self.name}_{os.path.basename(report_json)}'
shutil.copy(report_json, os.path.join(os.environ['PIPERIDER_REPORT_DIR'], report_name))
return report_name
def execute_custom_assertions(self, ge_context, report_file):
from piperider_cli.data.convert_to_exp import get_scheduled_tests
scheduled_tests = get_scheduled_tests()
if not scheduled_tests:
return
print(f"executing {len(scheduled_tests)} scheduled tests", )
for k, v in scheduled_tests.items():
try:
# execute the scheduled test
action_result = v.
| 1,305
|
1,992
| 41
| 4,510
|
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
infile
|
update_report
| true
|
function
| 15
| 15
| false
| true
|
[
"stage_file",
"console",
"name",
"stage_file_obj",
"source_file",
"__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.console.print(Markdown(markdown_template))
# save ydata report
with open(ydata_report_file, 'w') as fh:
outputs = self.refine_ydata_result(results)
fh.write(json.dumps(outputs))
self._show_result()
return outputs['has_error'], {'ge': ge_report_file, 'ydata': ydata_report_file}
except Exception as e:
# mark as error
self.console.print_exception(show_locals=True)
self._show_result(e)
return True, None
def copy_report(self, ge_workspace):
for report_json in glob(os.path.join(ge_workspace, 'great_expectations', 'uncommitted', '**', '*.json'),
recursive=True):
filename = os.path.basename(self.stage_file).split('.')[0]
report_name = f'{filename}_{self.name}_{os.path.basename(report_json)}'
shutil.copy(report_json, os.path.join(os.environ['PIPERIDER_REPORT_DIR'], report_name))
return report_name
def execute_custom_assertions(self, ge_context, report_file):
from piperider_cli.data.convert_to_exp import get_scheduled_tests
scheduled_tests = get_scheduled_tests()
if not scheduled_tests:
return
print(f"executing {len(scheduled_tests)} scheduled tests", )
for k, v in scheduled_tests.items():
try:
# execute the scheduled test
action_result = v.execute_and_remove_from_queue(ge_context)
if isinstance(action_result, bool):
self.
|
[
"stage_file",
"console",
"name",
"stage_file_obj",
"source_file",
"content",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"tests",
"update_report"
] |
ons_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.refine_ydata_result(results)
fh.write(json.dumps(outputs))
self._show_result()
return outputs['has_error'], {'ge': ge_report_file, 'ydata': ydata_report_file}
except Exception as e:
# mark as error
self.console.print_exception(show_locals=True)
self._show_result(e)
return True, None
def copy_report(self, ge_workspace):
for report_json in glob(os.path.join(ge_workspace, 'great_expectations', 'uncommitted', '**', '*.json'),
recursive=True):
filename = os.path.basename(self.stage_file).split('.')[0]
report_name = f'{filename}_{self.name}_{os.path.basename(report_json)}'
shutil.copy(report_json, os.path.join(os.environ['PIPERIDER_REPORT_DIR'], report_name))
return report_name
def execute_custom_assertions(self, ge_context, report_file):
from piperider_cli.data.convert_to_exp import get_scheduled_tests
scheduled_tests = get_scheduled_tests()
if not scheduled_tests:
return
print(f"executing {len(scheduled_tests)} scheduled tests", )
for k, v in scheduled_tests.items():
try:
# execute the scheduled test
action_result = v.execute_and_remove_from_queue(ge_context)
if isinstance(action_result, bool):
self.
| 1,306
|
1,993
| 41
| 4,757
|
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
infile
|
update_report
| true
|
function
| 15
| 15
| false
| false
|
[
"stage_file",
"console",
"name",
"stage_file_obj",
"source_file",
"__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.console.print(Markdown(markdown_template))
# save ydata report
with open(ydata_report_file, 'w') as fh:
outputs = self.refine_ydata_result(results)
fh.write(json.dumps(outputs))
self._show_result()
return outputs['has_error'], {'ge': ge_report_file, 'ydata': ydata_report_file}
except Exception as e:
# mark as error
self.console.print_exception(show_locals=True)
self._show_result(e)
return True, None
def copy_report(self, ge_workspace):
for report_json in glob(os.path.join(ge_workspace, 'great_expectations', 'uncommitted', '**', '*.json'),
recursive=True):
filename = os.path.basename(self.stage_file).split('.')[0]
report_name = f'{filename}_{self.name}_{os.path.basename(report_json)}'
shutil.copy(report_json, os.path.join(os.environ['PIPERIDER_REPORT_DIR'], report_name))
return report_name
def execute_custom_assertions(self, ge_context, report_file):
from piperider_cli.data.convert_to_exp import get_scheduled_tests
scheduled_tests = get_scheduled_tests()
if not scheduled_tests:
return
print(f"executing {len(scheduled_tests)} scheduled tests", )
for k, v in scheduled_tests.items():
try:
# execute the scheduled test
action_result = v.execute_and_remove_from_queue(ge_context)
if isinstance(action_result, bool):
self.update_report(report_file, v, action_result)
elif isinstance(action_result, pd.DataFrame):
values = action_result.all().values
if len(values) == 1 and values[0]:
self.
|
[
"stage_file",
"console",
"name",
"stage_file_obj",
"source_file",
"content",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"tests",
"update_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.refine_ydata_result(results)
fh.write(json.dumps(outputs))
self._show_result()
return outputs['has_error'], {'ge': ge_report_file, 'ydata': ydata_report_file}
except Exception as e:
# mark as error
self.console.print_exception(show_locals=True)
self._show_result(e)
return True, None
def copy_report(self, ge_workspace):
for report_json in glob(os.path.join(ge_workspace, 'great_expectations', 'uncommitted', '**', '*.json'),
recursive=True):
filename = os.path.basename(self.stage_file).split('.')[0]
report_name = f'{filename}_{self.name}_{os.path.basename(report_json)}'
shutil.copy(report_json, os.path.join(os.environ['PIPERIDER_REPORT_DIR'], report_name))
return report_name
def execute_custom_assertions(self, ge_context, report_file):
from piperider_cli.data.convert_to_exp import get_scheduled_tests
scheduled_tests = get_scheduled_tests()
if not scheduled_tests:
return
print(f"executing {len(scheduled_tests)} scheduled tests", )
for k, v in scheduled_tests.items():
try:
# execute the scheduled test
action_result = v.execute_and_remove_from_queue(ge_context)
if isinstance(action_result, bool):
self.update_report(report_file, v, action_result)
elif isinstance(action_result, pd.DataFrame):
values = action_result.all().values
if len(values) == 1 and values[0]:
self.
| 1,307
|
1,994
| 41
| 4,872
|
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
infile
|
update_report
| true
|
function
| 15
| 15
| false
| false
|
[
"stage_file",
"console",
"name",
"stage_file_obj",
"source_file",
"__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.console.print(Markdown(markdown_template))
# save ydata report
with open(ydata_report_file, 'w') as fh:
outputs = self.refine_ydata_result(results)
fh.write(json.dumps(outputs))
self._show_result()
return outputs['has_error'], {'ge': ge_report_file, 'ydata': ydata_report_file}
except Exception as e:
# mark as error
self.console.print_exception(show_locals=True)
self._show_result(e)
return True, None
def copy_report(self, ge_workspace):
for report_json in glob(os.path.join(ge_workspace, 'great_expectations', 'uncommitted', '**', '*.json'),
recursive=True):
filename = os.path.basename(self.stage_file).split('.')[0]
report_name = f'{filename}_{self.name}_{os.path.basename(report_json)}'
shutil.copy(report_json, os.path.join(os.environ['PIPERIDER_REPORT_DIR'], report_name))
return report_name
def execute_custom_assertions(self, ge_context, report_file):
from piperider_cli.data.convert_to_exp import get_scheduled_tests
scheduled_tests = get_scheduled_tests()
if not scheduled_tests:
return
print(f"executing {len(scheduled_tests)} scheduled tests", )
for k, v in scheduled_tests.items():
try:
# execute the scheduled test
action_result = v.execute_and_remove_from_queue(ge_context)
if isinstance(action_result, bool):
self.update_report(report_file, v, action_result)
elif isinstance(action_result, pd.DataFrame):
values = action_result.all().values
if len(values) == 1 and values[0]:
self.update_report(report_file, v, True if values[0] else False)
else:
self.
|
[
"stage_file",
"console",
"name",
"stage_file_obj",
"source_file",
"content",
"copy_report",
"execute_custom_assertions",
"refine_ydata_result",
"run",
"tests",
"update_report"
] |
# save ydata report
with open(ydata_report_file, 'w') as fh:
outputs = self.refine_ydata_result(results)
fh.write(json.dumps(outputs))
self._show_result()
return outputs['has_error'], {'ge': ge_report_file, 'ydata': ydata_report_file}
except Exception as e:
# mark as error
self.console.print_exception(show_locals=True)
self._show_result(e)
return True, None
def copy_report(self, ge_workspace):
for report_json in glob(os.path.join(ge_workspace, 'great_expectations', 'uncommitted', '**', '*.json'),
recursive=True):
filename = os.path.basename(self.stage_file).split('.')[0]
report_name = f'{filename}_{self.name}_{os.path.basename(report_json)}'
shutil.copy(report_json, os.path.join(os.environ['PIPERIDER_REPORT_DIR'], report_name))
return report_name
def execute_custom_assertions(self, ge_context, report_file):
from piperider_cli.data.convert_to_exp import get_scheduled_tests
scheduled_tests = get_scheduled_tests()
if not scheduled_tests:
return
print(f"executing {len(scheduled_tests)} scheduled tests", )
for k, v in scheduled_tests.items():
try:
# execute the scheduled test
action_result = v.execute_and_remove_from_queue(ge_context)
if isinstance(action_result, bool):
self.update_report(report_file, v, action_result)
elif isinstance(action_result, pd.DataFrame):
values = action_result.all().values
if len(values) == 1 and values[0]:
self.update_report(report_file, v, True if values[0] else False)
else:
self.
| 1,308
|
2,004
| 41
| 8,011
|
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
infile
|
stage_content
| true
|
statement
| 5
| 5
| false
| false
|
[
"stage_content",
"stage_file",
"filename",
"stages",
"get",
"__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": "filename",
"type": "statement"
},
{
"name": "get",
"type": "function"
},
{
"name": "stage_content",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stages",
"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.refine_ydata_result(results)
fh.write(json.dumps(outputs))
self._show_result()
return outputs['has_error'], {'ge': ge_report_file, 'ydata': ydata_report_file}
except Exception as e:
# mark as error
self.console.print_exception(show_locals=True)
self._show_result(e)
return True, None
def copy_report(self, ge_workspace):
for report_json in glob(os.path.join(ge_workspace, 'great_expectations', 'uncommitted', '**', '*.json'),
recursive=True):
filename = os.path.basename(self.stage_file).split('.')[0]
report_name = f'{filename}_{self.name}_{os.path.basename(report_json)}'
shutil.copy(report_json, os.path.join(os.environ['PIPERIDER_REPORT_DIR'], report_name))
return report_name
def execute_custom_assertions(self, ge_context, report_file):
from piperider_cli.data.convert_to_exp import get_scheduled_tests
scheduled_tests = get_scheduled_tests()
if not scheduled_tests:
return
print(f"executing {len(scheduled_tests)} scheduled tests", )
for k, v in scheduled_tests.items():
try:
# execute the scheduled test
action_result = v.execute_and_remove_from_queue(ge_context)
if isinstance(action_result, bool):
self.update_report(report_file, v, action_result)
elif isinstance(action_result, pd.DataFrame):
values = action_result.all().values
if len(values) == 1 and values[0]:
self.update_report(report_file, v, True if values[0] else False)
else:
self.update_report(report_file, v, False)
except Exception as e:
click.echo(f'Error: {e}')
raise
finally:
# TODO update the report to ge's output
pass
def update_report(self, report_file, custom_assertion, action_result):
with open(report_file) as fh:
report_data = json.loads(fh.read())
results = report_data['results']
kwargs = {
"batch_id": "68826d1fc4627a6685f0291acd9c54bb",
}
if 'column' in custom_assertion.test_definition:
kwargs['column'] = custom_assertion.test_definition['column']
results.append(
{
"exception_info": {
"exception_message": None,
"exception_traceback": None,
"raised_exception": False
},
"expectation_config": {
"expectation_type": f"custom-assertion::{custom_assertion.function_name}",
"kwargs": kwargs,
"meta": {
"test_definition": custom_assertion.test_definition,
"function_name": custom_assertion.function_name
}
},
"meta": {},
"result": {},
"success": action_result
}
)
if not action_result:
report_data['success'] = False
all_count = len(results)
success_count = len([r for r in results if r['success']])
report_data['statistics'] = {
'evaluated_expectations': all_count,
'success_percent': 100 * (success_count / all_count),
'successful_expectations': success_count,
'unsuccessful_expectations': all_count - success_count}
# write back to file
with open(report_file, 'w') as fd:
fd.write(json.dumps(report_data, indent=2))
pass
def refine_ydata_result(self, results: dict):
outputs = {'has_error': True}
for k, v in results.items():
if 'Expectation Level Assessment' == k:
refined_assessment = list(v)
for idx, elem in enumerate(refined_assessment):
if isinstance(elem, pd.DataFrame):
refined_assessment[idx] = elem.to_json(orient='table')
outputs['has_error'] = False if elem['Successful?'].all() else True
outputs[k] = refined_assessment
else:
outputs[k] = v
return outputs
class StageFile(object):
def __init__(self, stage_file):
self.stage_file = stage_file
from piperider_cli.config import load_stages
self.stage_content: dict = load_stages(stage_file)
self.filename = stage_file
def stages(self):
for k in self.stage_content.keys():
yield Stage(self, k, self.
|
[
"stage_content",
"stage_file",
"filename",
"stages",
"get"
] |
ssertion.test_definition,
"function_name": custom_assertion.function_name
}
},
"meta": {},
"result": {},
"success": action_result
}
)
if not action_result:
report_data['success'] = False
all_count = len(results)
success_count = len([r for r in results if r['success']])
report_data['statistics'] = {
'evaluated_expectations': all_count,
'success_percent': 100 * (success_count / all_count),
'successful_expectations': success_count,
'unsuccessful_expectations': all_count - success_count}
# write back to file
with open(report_file, 'w') as fd:
fd.write(json.dumps(report_data, indent=2))
pass
def refine_ydata_result(self, results: dict):
outputs = {'has_error': True}
for k, v in results.items():
if 'Expectation Level Assessment' == k:
refined_assessment = list(v)
for idx, elem in enumerate(refined_assessment):
if isinstance(elem, pd.DataFrame):
refined_assessment[idx] = elem.to_json(orient='table')
outputs['has_error'] = False if elem['Successful?'].all() else True
outputs[k] = refined_assessment
else:
outputs[k] = v
return outputs
class StageFile(object):
def __init__(self, stage_file):
self.stage_file = stage_file
from piperider_cli.config import load_stages
self.stage_content: dict = load_stages(stage_file)
self.filename = stage_file
def stages(self):
for k in self.stage_content.keys():
yield Stage(self, k, self.
| 1,310
|
2,006
| 41
| 8,136
|
infuseai__piperider
|
dd48dc6fa4e4b8c444379b196718555db75ce6fe
|
piperider_cli/stage.py
|
infile
|
stage_content
| true
|
statement
| 5
| 5
| false
| false
|
[
"stage_content",
"stage_file",
"stages",
"filename",
"get",
"__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": "filename",
"type": "statement"
},
{
"name": "get",
"type": "function"
},
{
"name": "stage_content",
"type": "statement"
},
{
"name": "stage_file",
"type": "statement"
},
{
"name": "stages",
"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.refine_ydata_result(results)
fh.write(json.dumps(outputs))
self._show_result()
return outputs['has_error'], {'ge': ge_report_file, 'ydata': ydata_report_file}
except Exception as e:
# mark as error
self.console.print_exception(show_locals=True)
self._show_result(e)
return True, None
def copy_report(self, ge_workspace):
for report_json in glob(os.path.join(ge_workspace, 'great_expectations', 'uncommitted', '**', '*.json'),
recursive=True):
filename = os.path.basename(self.stage_file).split('.')[0]
report_name = f'{filename}_{self.name}_{os.path.basename(report_json)}'
shutil.copy(report_json, os.path.join(os.environ['PIPERIDER_REPORT_DIR'], report_name))
return report_name
def execute_custom_assertions(self, ge_context, report_file):
from piperider_cli.data.convert_to_exp import get_scheduled_tests
scheduled_tests = get_scheduled_tests()
if not scheduled_tests:
return
print(f"executing {len(scheduled_tests)} scheduled tests", )
for k, v in scheduled_tests.items():
try:
# execute the scheduled test
action_result = v.execute_and_remove_from_queue(ge_context)
if isinstance(action_result, bool):
self.update_report(report_file, v, action_result)
elif isinstance(action_result, pd.DataFrame):
values = action_result.all().values
if len(values) == 1 and values[0]:
self.update_report(report_file, v, True if values[0] else False)
else:
self.update_report(report_file, v, False)
except Exception as e:
click.echo(f'Error: {e}')
raise
finally:
# TODO update the report to ge's output
pass
def update_report(self, report_file, custom_assertion, action_result):
with open(report_file) as fh:
report_data = json.loads(fh.read())
results = report_data['results']
kwargs = {
"batch_id": "68826d1fc4627a6685f0291acd9c54bb",
}
if 'column' in custom_assertion.test_definition:
kwargs['column'] = custom_assertion.test_definition['column']
results.append(
{
"exception_info": {
"exception_message": None,
"exception_traceback": None,
"raised_exception": False
},
"expectation_config": {
"expectation_type": f"custom-assertion::{custom_assertion.function_name}",
"kwargs": kwargs,
"meta": {
"test_definition": custom_assertion.test_definition,
"function_name": custom_assertion.function_name
}
},
"meta": {},
"result": {},
"success": action_result
}
)
if not action_result:
report_data['success'] = False
all_count = len(results)
success_count = len([r for r in results if r['success']])
report_data['statistics'] = {
'evaluated_expectations': all_count,
'success_percent': 100 * (success_count / all_count),
'successful_expectations': success_count,
'unsuccessful_expectations': all_count - success_count}
# write back to file
with open(report_file, 'w') as fd:
fd.write(json.dumps(report_data, indent=2))
pass
def refine_ydata_result(self, results: dict):
outputs = {'has_error': True}
for k, v in results.items():
if 'Expectation Level Assessment' == k:
refined_assessment = list(v)
for idx, elem in enumerate(refined_assessment):
if isinstance(elem, pd.DataFrame):
refined_assessment[idx] = elem.to_json(orient='table')
outputs['has_error'] = False if elem['Successful?'].all() else True
outputs[k] = refined_assessment
else:
outputs[k] = v
return outputs
class StageFile(object):
def __init__(self, stage_file):
self.stage_file = stage_file
from piperider_cli.config import load_stages
self.stage_content: dict = load_stages(stage_file)
self.filename = stage_file
def stages(self):
for k in self.stage_content.keys():
yield Stage(self, k, self.stage_content[k])
def get(self, name):
if name in self.stage_content:
return Stage(self, name, self.
|
[
"stage_content",
"stage_file",
"stages",
"filename",
"get"
] |
}
},
"meta": {},
"result": {},
"success": action_result
}
)
if not action_result:
report_data['success'] = False
all_count = len(results)
success_count = len([r for r in results if r['success']])
report_data['statistics'] = {
'evaluated_expectations': all_count,
'success_percent': 100 * (success_count / all_count),
'successful_expectations': success_count,
'unsuccessful_expectations': all_count - success_count}
# write back to file
with open(report_file, 'w') as fd:
fd.write(json.dumps(report_data, indent=2))
pass
def refine_ydata_result(self, results: dict):
outputs = {'has_error': True}
for k, v in results.items():
if 'Expectation Level Assessment' == k:
refined_assessment = list(v)
for idx, elem in enumerate(refined_assessment):
if isinstance(elem, pd.DataFrame):
refined_assessment[idx] = elem.to_json(orient='table')
outputs['has_error'] = False if elem['Successful?'].all() else True
outputs[k] = refined_assessment
else:
outputs[k] = v
return outputs
class StageFile(object):
def __init__(self, stage_file):
self.stage_file = stage_file
from piperider_cli.config import load_stages
self.stage_content: dict = load_stages(stage_file)
self.filename = stage_file
def stages(self):
for k in self.stage_content.keys():
yield Stage(self, k, self.stage_content[k])
def get(self, name):
if name in self.stage_content:
return Stage(self, name, self.
| 1,312
|
2,018
| 42
| 1,360
|
infuseai__piperider
|
0e61a9aa50ab4b155345c55a133e041235032597
|
piperider_cli/datasource.py
|
infile
|
Text
| true
|
module
| 14
| 16
| false
| true
|
[
"Text",
"Path",
"Password",
"List",
"key",
"Checkbox",
"Confirm",
"ConsoleRender",
"Editor",
"HackedConsoleRender",
"LimitedCheckbox",
"LimitedCheckboxQuestion",
"prompt_ex",
"Question"
] |
[
{
"name": "Checkbox",
"type": "module"
},
{
"name": "Confirm",
"type": "module"
},
{
"name": "ConsoleRender",
"type": "module"
},
{
"name": "Editor",
"type": "module"
},
{
"name": "errors",
"type": "module"
},
{
"name": "HackedConsoleRender",
"type": "class"
},
{
"name": "key",
"type": "module"
},
{
"name": "LimitedCheckbox",
"type": "class"
},
{
"name": "LimitedCheckboxQuestion",
"type": "class"
},
{
"name": "List",
"type": "module"
},
{
"name": "Password",
"type": "module"
},
{
"name": "Path",
"type": "module"
},
{
"name": "prompt_ex",
"type": "function"
},
{
"name": "Question",
"type": "module"
},
{
"name": "Text",
"type": "module"
},
{
"name": "themes",
"type": "module"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.
|
[
"Text",
"Path",
"Password",
"List",
"key",
"Checkbox",
"Confirm",
"ConsoleRender",
"Editor",
"HackedConsoleRender",
"LimitedCheckbox",
"LimitedCheckboxQuestion",
"prompt_ex",
"Question"
] |
import os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.
| 1,315
|
2,019
| 42
| 1,370
|
infuseai__piperider
|
0e61a9aa50ab4b155345c55a133e041235032597
|
piperider_cli/datasource.py
|
infile
|
name
| true
|
statement
| 10
| 10
| false
| true
|
[
"name",
"default",
"validate",
"description",
"type",
"__init__",
"get",
"optional",
"question",
"set",
"value",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "default",
"type": "statement"
},
{
"name": "description",
"type": "statement"
},
{
"name": "get",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "optional",
"type": "statement"
},
{
"name": "question",
"type": "function"
},
{
"name": "set",
"type": "function"
},
{
"name": "type",
"type": "statement"
},
{
"name": "validate",
"type": "statement"
},
{
"name": "value",
"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 os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.
|
[
"name",
"default",
"validate",
"description",
"type",
"get",
"optional",
"question",
"set",
"value"
] |
import os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.
| 1,316
|
2,020
| 42
| 1,389
|
infuseai__piperider
|
0e61a9aa50ab4b155345c55a133e041235032597
|
piperider_cli/datasource.py
|
infile
|
description
| true
|
statement
| 10
| 10
| false
| true
|
[
"default",
"validate",
"name",
"description",
"type",
"__init__",
"get",
"optional",
"question",
"set",
"value",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "default",
"type": "statement"
},
{
"name": "description",
"type": "statement"
},
{
"name": "get",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "optional",
"type": "statement"
},
{
"name": "question",
"type": "function"
},
{
"name": "set",
"type": "function"
},
{
"name": "type",
"type": "statement"
},
{
"name": "validate",
"type": "statement"
},
{
"name": "value",
"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 os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.
|
[
"default",
"validate",
"name",
"description",
"type",
"get",
"optional",
"question",
"set",
"value"
] |
import os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.
| 1,317
|
2,021
| 42
| 1,415
|
infuseai__piperider
|
0e61a9aa50ab4b155345c55a133e041235032597
|
piperider_cli/datasource.py
|
infile
|
default
| true
|
statement
| 10
| 10
| false
| true
|
[
"default",
"description",
"validate",
"name",
"value",
"__init__",
"get",
"optional",
"question",
"set",
"type",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "default",
"type": "statement"
},
{
"name": "description",
"type": "statement"
},
{
"name": "get",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "optional",
"type": "statement"
},
{
"name": "question",
"type": "function"
},
{
"name": "set",
"type": "function"
},
{
"name": "type",
"type": "statement"
},
{
"name": "validate",
"type": "statement"
},
{
"name": "value",
"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 os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.
|
[
"default",
"description",
"validate",
"name",
"value",
"get",
"optional",
"question",
"set",
"type"
] |
import os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.
| 1,318
|
2,022
| 42
| 1,438
|
infuseai__piperider
|
0e61a9aa50ab4b155345c55a133e041235032597
|
piperider_cli/datasource.py
|
infile
|
validate
| true
|
statement
| 10
| 10
| false
| true
|
[
"validate",
"default",
"description",
"name",
"value",
"__init__",
"get",
"optional",
"question",
"set",
"type",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "default",
"type": "statement"
},
{
"name": "description",
"type": "statement"
},
{
"name": "get",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "optional",
"type": "statement"
},
{
"name": "question",
"type": "function"
},
{
"name": "set",
"type": "function"
},
{
"name": "type",
"type": "statement"
},
{
"name": "validate",
"type": "statement"
},
{
"name": "value",
"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 os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.
|
[
"validate",
"default",
"description",
"name",
"value",
"get",
"optional",
"question",
"set",
"type"
] |
import os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.
| 1,319
|
2,029
| 42
| 2,723
|
infuseai__piperider
|
0e61a9aa50ab4b155345c55a133e041235032597
|
piperider_cli/datasource.py
|
infile
|
Text
| true
|
module
| 14
| 16
| false
| false
|
[
"Text",
"Path",
"Password",
"List",
"key",
"Checkbox",
"Confirm",
"ConsoleRender",
"Editor",
"HackedConsoleRender",
"LimitedCheckbox",
"LimitedCheckboxQuestion",
"prompt_ex",
"Question"
] |
[
{
"name": "Checkbox",
"type": "module"
},
{
"name": "Confirm",
"type": "module"
},
{
"name": "ConsoleRender",
"type": "module"
},
{
"name": "Editor",
"type": "module"
},
{
"name": "errors",
"type": "module"
},
{
"name": "HackedConsoleRender",
"type": "class"
},
{
"name": "key",
"type": "module"
},
{
"name": "LimitedCheckbox",
"type": "class"
},
{
"name": "LimitedCheckboxQuestion",
"type": "class"
},
{
"name": "List",
"type": "module"
},
{
"name": "Password",
"type": "module"
},
{
"name": "Path",
"type": "module"
},
{
"name": "prompt_ex",
"type": "function"
},
{
"name": "Question",
"type": "module"
},
{
"name": "Text",
"type": "module"
},
{
"name": "themes",
"type": "module"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.
|
[
"Text",
"Path",
"Password",
"List",
"key",
"Checkbox",
"Confirm",
"ConsoleRender",
"Editor",
"HackedConsoleRender",
"LimitedCheckbox",
"LimitedCheckboxQuestion",
"prompt_ex",
"Question"
] |
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.
| 1,326
|
2,030
| 42
| 2,733
|
infuseai__piperider
|
0e61a9aa50ab4b155345c55a133e041235032597
|
piperider_cli/datasource.py
|
infile
|
name
| true
|
statement
| 10
| 10
| false
| false
|
[
"name",
"default",
"validate",
"description",
"type",
"__init__",
"get",
"optional",
"question",
"set",
"value",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "default",
"type": "statement"
},
{
"name": "description",
"type": "statement"
},
{
"name": "get",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "optional",
"type": "statement"
},
{
"name": "question",
"type": "function"
},
{
"name": "set",
"type": "function"
},
{
"name": "type",
"type": "statement"
},
{
"name": "validate",
"type": "statement"
},
{
"name": "value",
"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 os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.
|
[
"name",
"default",
"validate",
"description",
"type",
"get",
"optional",
"question",
"set",
"value"
] |
lse:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.
| 1,327
|
2,031
| 42
| 2,752
|
infuseai__piperider
|
0e61a9aa50ab4b155345c55a133e041235032597
|
piperider_cli/datasource.py
|
infile
|
description
| true
|
statement
| 10
| 10
| false
| false
|
[
"name",
"default",
"validate",
"description",
"value",
"__init__",
"get",
"optional",
"question",
"set",
"type",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "default",
"type": "statement"
},
{
"name": "description",
"type": "statement"
},
{
"name": "get",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "optional",
"type": "statement"
},
{
"name": "question",
"type": "function"
},
{
"name": "set",
"type": "function"
},
{
"name": "type",
"type": "statement"
},
{
"name": "validate",
"type": "statement"
},
{
"name": "value",
"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 os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.
|
[
"name",
"default",
"validate",
"description",
"value",
"get",
"optional",
"question",
"set",
"type"
] |
lf.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.
| 1,328
|
2,032
| 42
| 2,782
|
infuseai__piperider
|
0e61a9aa50ab4b155345c55a133e041235032597
|
piperider_cli/datasource.py
|
infile
|
default
| true
|
statement
| 10
| 10
| false
| false
|
[
"default",
"name",
"description",
"validate",
"value",
"__init__",
"get",
"optional",
"question",
"set",
"type",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "default",
"type": "statement"
},
{
"name": "description",
"type": "statement"
},
{
"name": "get",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "optional",
"type": "statement"
},
{
"name": "question",
"type": "function"
},
{
"name": "set",
"type": "function"
},
{
"name": "type",
"type": "statement"
},
{
"name": "validate",
"type": "statement"
},
{
"name": "value",
"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 os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=str(self.
|
[
"default",
"name",
"description",
"validate",
"value",
"get",
"optional",
"question",
"set",
"type"
] |
e_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=str(self.
| 1,329
|
2,033
| 42
| 2,806
|
infuseai__piperider
|
0e61a9aa50ab4b155345c55a133e041235032597
|
piperider_cli/datasource.py
|
infile
|
validate
| true
|
statement
| 10
| 10
| false
| false
|
[
"validate",
"default",
"description",
"name",
"value",
"__init__",
"get",
"optional",
"question",
"set",
"type",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "default",
"type": "statement"
},
{
"name": "description",
"type": "statement"
},
{
"name": "get",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "optional",
"type": "statement"
},
{
"name": "question",
"type": "function"
},
{
"name": "set",
"type": "function"
},
{
"name": "type",
"type": "statement"
},
{
"name": "validate",
"type": "statement"
},
{
"name": "value",
"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 os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=str(self.default), validate=self.
|
[
"validate",
"default",
"description",
"name",
"value",
"get",
"optional",
"question",
"set",
"type"
] |
ue else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=str(self.default), validate=self.
| 1,330
|
2,035
| 42
| 3,102
|
infuseai__piperider
|
0e61a9aa50ab4b155345c55a133e041235032597
|
piperider_cli/datasource.py
|
infile
|
Password
| true
|
module
| 14
| 16
| false
| true
|
[
"Text",
"Path",
"List",
"key",
"Question",
"Checkbox",
"Confirm",
"ConsoleRender",
"Editor",
"HackedConsoleRender",
"LimitedCheckbox",
"LimitedCheckboxQuestion",
"Password",
"prompt_ex"
] |
[
{
"name": "Checkbox",
"type": "module"
},
{
"name": "Confirm",
"type": "module"
},
{
"name": "ConsoleRender",
"type": "module"
},
{
"name": "Editor",
"type": "module"
},
{
"name": "errors",
"type": "module"
},
{
"name": "HackedConsoleRender",
"type": "class"
},
{
"name": "key",
"type": "module"
},
{
"name": "LimitedCheckbox",
"type": "class"
},
{
"name": "LimitedCheckboxQuestion",
"type": "class"
},
{
"name": "List",
"type": "module"
},
{
"name": "Password",
"type": "module"
},
{
"name": "Path",
"type": "module"
},
{
"name": "prompt_ex",
"type": "function"
},
{
"name": "Question",
"type": "module"
},
{
"name": "Text",
"type": "module"
},
{
"name": "themes",
"type": "module"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=str(self.default), validate=self.validate)
class PasswordField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "password", value, default, description, validate, optional)
def question(self):
return inquirer.
|
[
"Text",
"Path",
"List",
"key",
"Question",
"Checkbox",
"Confirm",
"ConsoleRender",
"Editor",
"HackedConsoleRender",
"LimitedCheckbox",
"LimitedCheckboxQuestion",
"Password",
"prompt_ex"
] |
on=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=str(self.default), validate=self.validate)
class PasswordField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "password", value, default, description, validate, optional)
def question(self):
return inquirer.
| 1,332
|
2,036
| 42
| 3,116
|
infuseai__piperider
|
0e61a9aa50ab4b155345c55a133e041235032597
|
piperider_cli/datasource.py
|
infile
|
name
| true
|
statement
| 10
| 10
| false
| false
|
[
"name",
"default",
"validate",
"description",
"type",
"__init__",
"get",
"optional",
"question",
"set",
"value",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "default",
"type": "statement"
},
{
"name": "description",
"type": "statement"
},
{
"name": "get",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "optional",
"type": "statement"
},
{
"name": "question",
"type": "function"
},
{
"name": "set",
"type": "function"
},
{
"name": "type",
"type": "statement"
},
{
"name": "validate",
"type": "statement"
},
{
"name": "value",
"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 os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=str(self.default), validate=self.validate)
class PasswordField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "password", value, default, description, validate, optional)
def question(self):
return inquirer.Password(self.
|
[
"name",
"default",
"validate",
"description",
"type",
"get",
"optional",
"question",
"set",
"value"
] |
ate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=str(self.default), validate=self.validate)
class PasswordField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "password", value, default, description, validate, optional)
def question(self):
return inquirer.Password(self.
| 1,333
|
2,037
| 42
| 3,135
|
infuseai__piperider
|
0e61a9aa50ab4b155345c55a133e041235032597
|
piperider_cli/datasource.py
|
infile
|
description
| true
|
statement
| 10
| 10
| false
| false
|
[
"default",
"validate",
"name",
"description",
"type",
"__init__",
"get",
"optional",
"question",
"set",
"value",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "default",
"type": "statement"
},
{
"name": "description",
"type": "statement"
},
{
"name": "get",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "optional",
"type": "statement"
},
{
"name": "question",
"type": "function"
},
{
"name": "set",
"type": "function"
},
{
"name": "type",
"type": "statement"
},
{
"name": "validate",
"type": "statement"
},
{
"name": "value",
"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 os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=str(self.default), validate=self.validate)
class PasswordField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "password", value, default, description, validate, optional)
def question(self):
return inquirer.Password(self.name, message=self.
|
[
"default",
"validate",
"name",
"description",
"type",
"get",
"optional",
"question",
"set",
"value"
] |
False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=str(self.default), validate=self.validate)
class PasswordField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "password", value, default, description, validate, optional)
def question(self):
return inquirer.Password(self.name, message=self.
| 1,334
|
2,038
| 42
| 3,161
|
infuseai__piperider
|
0e61a9aa50ab4b155345c55a133e041235032597
|
piperider_cli/datasource.py
|
infile
|
default
| true
|
statement
| 10
| 10
| false
| false
|
[
"default",
"description",
"validate",
"name",
"value",
"__init__",
"get",
"optional",
"question",
"set",
"type",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "default",
"type": "statement"
},
{
"name": "description",
"type": "statement"
},
{
"name": "get",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "optional",
"type": "statement"
},
{
"name": "question",
"type": "function"
},
{
"name": "set",
"type": "function"
},
{
"name": "type",
"type": "statement"
},
{
"name": "validate",
"type": "statement"
},
{
"name": "value",
"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 os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=str(self.default), validate=self.validate)
class PasswordField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "password", value, default, description, validate, optional)
def question(self):
return inquirer.Password(self.name, message=self.description, default=self.
|
[
"default",
"description",
"validate",
"name",
"value",
"get",
"optional",
"question",
"set",
"type"
] |
init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=str(self.default), validate=self.validate)
class PasswordField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "password", value, default, description, validate, optional)
def question(self):
return inquirer.Password(self.name, message=self.description, default=self.
| 1,335
|
2,039
| 42
| 3,184
|
infuseai__piperider
|
0e61a9aa50ab4b155345c55a133e041235032597
|
piperider_cli/datasource.py
|
infile
|
validate
| true
|
statement
| 10
| 10
| false
| false
|
[
"validate",
"default",
"description",
"name",
"value",
"__init__",
"get",
"optional",
"question",
"set",
"type",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "default",
"type": "statement"
},
{
"name": "description",
"type": "statement"
},
{
"name": "get",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "optional",
"type": "statement"
},
{
"name": "question",
"type": "function"
},
{
"name": "set",
"type": "function"
},
{
"name": "type",
"type": "statement"
},
{
"name": "validate",
"type": "statement"
},
{
"name": "value",
"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 os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=str(self.default), validate=self.validate)
class PasswordField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "password", value, default, description, validate, optional)
def question(self):
return inquirer.Password(self.name, message=self.description, default=self.default, validate=self.
|
[
"validate",
"default",
"description",
"name",
"value",
"get",
"optional",
"question",
"set",
"type"
] |
lue, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=str(self.default), validate=self.validate)
class PasswordField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "password", value, default, description, validate, optional)
def question(self):
return inquirer.Password(self.name, message=self.description, default=self.default, validate=self.
| 1,336
|
2,050
| 42
| 4,443
|
infuseai__piperider
|
0e61a9aa50ab4b155345c55a133e041235032597
|
piperider_cli/datasource.py
|
infile
|
verify_connector
| true
|
function
| 13
| 13
| false
| true
|
[
"type_name",
"fields",
"name",
"credential",
"validate",
"__init__",
"_validate_required_fields",
"args",
"ask",
"ask_credential",
"engine_args",
"show_installation_information",
"to_database_url",
"verify_connector",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "args",
"type": "statement"
},
{
"name": "ask",
"type": "function"
},
{
"name": "ask_credential",
"type": "function"
},
{
"name": "credential",
"type": "statement"
},
{
"name": "engine_args",
"type": "function"
},
{
"name": "fields",
"type": "statement"
},
{
"name": "name",
"type": "statement"
},
{
"name": "show_installation_information",
"type": "function"
},
{
"name": "to_database_url",
"type": "function"
},
{
"name": "type_name",
"type": "statement"
},
{
"name": "validate",
"type": "function"
},
{
"name": "verify_connector",
"type": "function"
},
{
"name": "_validate_required_fields",
"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 os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=str(self.default), validate=self.validate)
class PasswordField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "password", value, default, description, validate, optional)
def question(self):
return inquirer.Password(self.name, message=self.description, default=self.default, validate=self.validate)
class DataSource(metaclass=ABCMeta):
def __init__(self, name, type_name, credential=None, **kwargs):
self.name = name
self.type_name = type_name
self.args = kwargs
self.fields: List[DataSourceField] = []
self.credential: Dict = credential or {}
def _validate_required_fields(self):
reasons = []
# check required fields
for f in self.fields:
if f.name not in self.credential and f.optional is False:
reasons.append(f"{f.name} is required")
return reasons == [], reasons
@abstractmethod
def validate(self):
"""
validate type name and required fields.
Returns True if everything is fine, False and reasons otherwise.
:return: bool, []
"""
raise NotImplemented
@abstractmethod
def to_database_url(self):
"""
build a database url for sqlalchemy create_engine method
:return:
"""
raise NotImplemented
@abstractmethod
def verify_connector(self):
raise NotImplemented
def engine_args(self):
return dict()
def show_installation_information(self):
from rich.markup import escape
if self.
|
[
"type_name",
"fields",
"name",
"credential",
"validate",
"args",
"ask",
"ask_credential",
"engine_args",
"show_installation_information",
"to_database_url",
"verify_connector"
] |
y_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=str(self.default), validate=self.validate)
class PasswordField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "password", value, default, description, validate, optional)
def question(self):
return inquirer.Password(self.name, message=self.description, default=self.default, validate=self.validate)
class DataSource(metaclass=ABCMeta):
def __init__(self, name, type_name, credential=None, **kwargs):
self.name = name
self.type_name = type_name
self.args = kwargs
self.fields: List[DataSourceField] = []
self.credential: Dict = credential or {}
def _validate_required_fields(self):
reasons = []
# check required fields
for f in self.fields:
if f.name not in self.credential and f.optional is False:
reasons.append(f"{f.name} is required")
return reasons == [], reasons
@abstractmethod
def validate(self):
"""
validate type name and required fields.
Returns True if everything is fine, False and reasons otherwise.
:return: bool, []
"""
raise NotImplemented
@abstractmethod
def to_database_url(self):
"""
build a database url for sqlalchemy create_engine method
:return:
"""
raise NotImplemented
@abstractmethod
def verify_connector(self):
raise NotImplemented
def engine_args(self):
return dict()
def show_installation_information(self):
from rich.markup import escape
if self.
| 1,342
|
2,053
| 42
| 4,870
|
infuseai__piperider
|
0e61a9aa50ab4b155345c55a133e041235032597
|
piperider_cli/datasource.py
|
infile
|
question
| true
|
function
| 10
| 10
| false
| true
|
[
"name",
"optional",
"question",
"type",
"value",
"__init__",
"default",
"description",
"get",
"set",
"validate",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "default",
"type": "statement"
},
{
"name": "description",
"type": "statement"
},
{
"name": "get",
"type": "function"
},
{
"name": "name",
"type": "statement"
},
{
"name": "optional",
"type": "statement"
},
{
"name": "question",
"type": "function"
},
{
"name": "set",
"type": "function"
},
{
"name": "type",
"type": "statement"
},
{
"name": "validate",
"type": "statement"
},
{
"name": "value",
"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 os
import re
import sys
import warnings
from abc import ABCMeta, abstractmethod
from typing import List, Dict
import inquirer
import readchar
from rich.console import Console
from sqlalchemy.exc import SAWarning
def _default_validate_func(answer, current) -> bool:
if isinstance(current, str):
return current.strip() != ''
return True
class DataSourceField(metaclass=ABCMeta):
def __init__(self, name, type, value=None, default=None, description=None, validate=True, optional=False):
self.name = name
self.type = type
self.default = default
self.description = description if not optional else f'{description} (optional)'
self.value = value
self.optional = optional
if optional:
self.validate = validate
else:
self.validate = _default_validate_func if validate == True else validate
def get(self):
return self.value
def set(self, value):
self.value = value
@abstractmethod
def question(self):
raise NotImplementedError
class TextField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "text", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=self.default, validate=self.validate)
class PathField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "path", value, default, description, validate, optional)
def question(self):
return inquirer.Path(self.name, message=self.description, default=self.default, exists=True)
class NumberField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
def _is_numeric_func(answer, current) -> bool:
return current.strip().isnumeric()
def _is_numeric_or_empty_func(answer, current) -> bool:
return current.strip().isnumeric() or current == ''
if value and not (isinstance(value, int) or isinstance(value, float)):
raise ValueError("Value must be a number")
if default and not (isinstance(default, int) or isinstance(default, float)):
raise ValueError("Default value must be a number")
if optional:
validate = _is_numeric_or_empty_func
else:
validate = _is_numeric_func
super().__init__(name, "number", value, default, description, validate, optional)
def question(self):
return inquirer.Text(self.name, message=self.description, default=str(self.default), validate=self.validate)
class PasswordField(DataSourceField):
def __init__(self, name, value=None, default=None, description=None, validate=True, optional=False):
super().__init__(name, "password", value, default, description, validate, optional)
def question(self):
return inquirer.Password(self.name, message=self.description, default=self.default, validate=self.validate)
class DataSource(metaclass=ABCMeta):
def __init__(self, name, type_name, credential=None, **kwargs):
self.name = name
self.type_name = type_name
self.args = kwargs
self.fields: List[DataSourceField] = []
self.credential: Dict = credential or {}
def _validate_required_fields(self):
reasons = []
# check required fields
for f in self.fields:
if f.name not in self.credential and f.optional is False:
reasons.append(f"{f.name} is required")
return reasons == [], reasons
@abstractmethod
def validate(self):
"""
validate type name and required fields.
Returns True if everything is fine, False and reasons otherwise.
:return: bool, []
"""
raise NotImplemented
@abstractmethod
def to_database_url(self):
"""
build a database url for sqlalchemy create_engine method
:return:
"""
raise NotImplemented
@abstractmethod
def verify_connector(self):
raise NotImplemented
def engine_args(self):
return dict()
def show_installation_information(self):
from rich.markup import escape
if self.verify_connector():
console = Console()
console.print(f'\n{escape(self.verify_connector())}\n')
def ask_credential(self):
"""
ask for user filling all fields.
"""
if sys.platform == "darwin":
# change readchar key backspace
readchar.key.BACKSPACE = '\x7F'
questions = []
for f in self.fields:
questions.append(f.
|
[
"name",
"optional",
"question",
"type",
"value",
"default",
"description",
"get",
"set",
"validate"
] |
al=False):
super().__init__(name, "password", value, default, description, validate, optional)
def question(self):
return inquirer.Password(self.name, message=self.description, default=self.default, validate=self.validate)
class DataSource(metaclass=ABCMeta):
def __init__(self, name, type_name, credential=None, **kwargs):
self.name = name
self.type_name = type_name
self.args = kwargs
self.fields: List[DataSourceField] = []
self.credential: Dict = credential or {}
def _validate_required_fields(self):
reasons = []
# check required fields
for f in self.fields:
if f.name not in self.credential and f.optional is False:
reasons.append(f"{f.name} is required")
return reasons == [], reasons
@abstractmethod
def validate(self):
"""
validate type name and required fields.
Returns True if everything is fine, False and reasons otherwise.
:return: bool, []
"""
raise NotImplemented
@abstractmethod
def to_database_url(self):
"""
build a database url for sqlalchemy create_engine method
:return:
"""
raise NotImplemented
@abstractmethod
def verify_connector(self):
raise NotImplemented
def engine_args(self):
return dict()
def show_installation_information(self):
from rich.markup import escape
if self.verify_connector():
console = Console()
console.print(f'\n{escape(self.verify_connector())}\n')
def ask_credential(self):
"""
ask for user filling all fields.
"""
if sys.platform == "darwin":
# change readchar key backspace
readchar.key.BACKSPACE = '\x7F'
questions = []
for f in self.fields:
questions.append(f.
| 1,345
|
2,082
| 43
| 496
|
infuseai__piperider
|
5047ef867db9d882cb61cdc4d9803b497ecf12e8
|
tests/test_builtin_validations.py
|
inproject
|
load_assertion_content
| true
|
function
| 15
| 19
| false
| true
|
[
"validate_assertions",
"load_assertion_content",
"load_all_assertions_for_validation",
"load_assertions",
"check_assertions_syntax",
"evaluate",
"evaluate_all",
"generate_recommended_assertions",
"generate_template_assertions",
"load_plugins",
"PIPERIDER_ASSERTION_PLUGIN_PATH",
"PIPERIDER_ASSERTION_SEARCH_PATH",
"PIPERIDER_ASSERTION_SUPPORT_METRICS",
"PIPERIDER_WORKSPACE_NAME",
"mro",
"__init__",
"__annotations__",
"__base__",
"__bases__",
"__basicsize__",
"__call__",
"__delattr__",
"__dict__",
"__dictoffset__",
"__dir__",
"__eq__",
"__flags__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__instancecheck__",
"__itemsize__",
"__mro__",
"__name__",
"__ne__",
"__new__",
"__or__",
"__prepare__",
"__qualname__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__ror__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasscheck__",
"__subclasses__",
"__subclasshook__",
"__text_signature__",
"__weakrefoffset__",
"__class__",
"__doc__",
"__module__"
] |
[
{
"name": "check_assertions_syntax",
"type": "function"
},
{
"name": "evaluate",
"type": "function"
},
{
"name": "evaluate_all",
"type": "function"
},
{
"name": "generate_recommended_assertions",
"type": "function"
},
{
"name": "generate_template_assertions",
"type": "function"
},
{
"name": "load_all_assertions_for_validation",
"type": "function"
},
{
"name": "load_assertion_content",
"type": "function"
},
{
"name": "load_assertions",
"type": "function"
},
{
"name": "load_plugins",
"type": "function"
},
{
"name": "mro",
"type": "function"
},
{
"name": "PIPERIDER_ASSERTION_PLUGIN_PATH",
"type": "statement"
},
{
"name": "PIPERIDER_ASSERTION_SEARCH_PATH",
"type": "statement"
},
{
"name": "PIPERIDER_ASSERTION_SUPPORT_METRICS",
"type": "statement"
},
{
"name": "PIPERIDER_WORKSPACE_NAME",
"type": "statement"
},
{
"name": "validate_assertions",
"type": "function"
},
{
"name": "_backup_assertion_file",
"type": "function"
},
{
"name": "_dump_assertions_files",
"type": "function"
},
{
"name": "_recommend_assertion_filename",
"type": "function"
},
{
"name": "_update_existing_recommended_assertions",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__base__",
"type": "statement"
},
{
"name": "__bases__",
"type": "statement"
},
{
"name": "__basicsize__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dictoffset__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__flags__",
"type": "statement"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__instancecheck__",
"type": "function"
},
{
"name": "__itemsize__",
"type": "statement"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mro__",
"type": "statement"
},
{
"name": "__name__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__prepare__",
"type": "function"
},
{
"name": "__qualname__",
"type": "statement"
},
{
"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": "__subclasscheck__",
"type": "function"
},
{
"name": "__subclasses__",
"type": "function"
},
{
"name": "__text_signature__",
"type": "statement"
},
{
"name": "__weakrefoffset__",
"type": "statement"
}
] |
from io import StringIO
from unittest import TestCase
from ruamel import yaml
from piperider_cli.assertion_engine import AssertionEngine
def _(assertion_content: str):
def content_provider(self):
self.assertions_content = yaml.safe_load(StringIO(assertion_content))
return [], []
return content_provider
class BuiltinValidationTests(TestCase):
def setUp(self) -> None:
self.engine = AssertionEngine(None)
self.origin_function = AssertionEngine.
|
[
"validate_assertions",
"load_assertion_content",
"load_all_assertions_for_validation",
"load_assertions",
"check_assertions_syntax",
"evaluate",
"evaluate_all",
"generate_recommended_assertions",
"generate_template_assertions",
"load_plugins",
"PIPERIDER_ASSERTION_PLUGIN_PATH",
"PIPERIDER_ASSERTION_SEARCH_PATH",
"PIPERIDER_ASSERTION_SUPPORT_METRICS",
"PIPERIDER_WORKSPACE_NAME",
"mro"
] |
from io import StringIO
from unittest import TestCase
from ruamel import yaml
from piperider_cli.assertion_engine import AssertionEngine
def _(assertion_content: str):
def content_provider(self):
self.assertions_content = yaml.safe_load(StringIO(assertion_content))
return [], []
return content_provider
class BuiltinValidationTests(TestCase):
def setUp(self) -> None:
self.engine = AssertionEngine(None)
self.origin_function = AssertionEngine.
| 1,365
|
2,084
| 43
| 606
|
infuseai__piperider
|
5047ef867db9d882cb61cdc4d9803b497ecf12e8
|
tests/test_builtin_validations.py
|
inproject
|
origin_function
| true
|
statement
| 86
| 90
| false
| true
|
[
"engine",
"_test_no_args_assertion",
"assertEqual",
"assertListEqual",
"origin_function",
"setUp",
"tearDown",
"test_validation_assert_column_exist",
"test_validation_assert_column_min_in_range",
"test_validation_assert_column_min_in_range_date",
"test_validation_assert_column_min_in_range_invalid_args",
"test_validation_assert_column_min_in_range_no_args",
"test_validation_assert_column_not_null",
"test_validation_assert_column_null",
"test_validation_assert_column_unique",
"test_validation_assert_row_count",
"test_validation_assert_row_count_in_range",
"test_validation_assert_row_count_in_range_invalid_args",
"test_validation_assert_row_count_in_range_no_args",
"test_validation_assert_row_count_invalid_args",
"addClassCleanup",
"addCleanup",
"addTypeEqualityFunc",
"assert_",
"assertAlmostEqual",
"assertAlmostEquals",
"assertCountEqual",
"assertDictContainsSubset",
"assertDictEqual",
"assertEquals",
"assertFalse",
"assertGreater",
"assertGreaterEqual",
"assertIn",
"assertIs",
"assertIsInstance",
"assertIsNone",
"assertIsNot",
"assertIsNotNone",
"assertLess",
"assertLessEqual",
"assertLogs",
"assertMultiLineEqual",
"assertNoLogs",
"assertNotAlmostEqual",
"assertNotAlmostEquals",
"assertNotEqual",
"assertNotEquals",
"assertNotIn",
"assertNotIsInstance",
"assertNotRegex",
"assertNotRegexpMatches",
"assertRaises",
"assertRaisesRegex",
"assertRaisesRegexp",
"assertRegex",
"assertRegexpMatches",
"assertSequenceEqual",
"assertSetEqual",
"assertTrue",
"assertTupleEqual",
"assertWarns",
"assertWarnsRegex",
"countTestCases",
"debug",
"defaultTestResult",
"doClassCleanups",
"doCleanups",
"fail",
"failIf",
"failIfAlmostEqual",
"failIfEqual",
"failUnless",
"failUnlessAlmostEqual",
"failUnlessEqual",
"failUnlessRaises",
"failureException",
"id",
"longMessage",
"maxDiff",
"run",
"setUpClass",
"shortDescription",
"skipTest",
"subTest",
"tearDownClass",
"__annotations__",
"__call__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "addClassCleanup",
"type": "function"
},
{
"name": "addCleanup",
"type": "function"
},
{
"name": "addTypeEqualityFunc",
"type": "function"
},
{
"name": "assert_",
"type": "function"
},
{
"name": "assertAlmostEqual",
"type": "function"
},
{
"name": "assertAlmostEquals",
"type": "function"
},
{
"name": "assertCountEqual",
"type": "function"
},
{
"name": "assertDictContainsSubset",
"type": "function"
},
{
"name": "assertDictEqual",
"type": "function"
},
{
"name": "assertEqual",
"type": "function"
},
{
"name": "assertEquals",
"type": "function"
},
{
"name": "assertFalse",
"type": "function"
},
{
"name": "assertGreater",
"type": "function"
},
{
"name": "assertGreaterEqual",
"type": "function"
},
{
"name": "assertIn",
"type": "function"
},
{
"name": "assertIs",
"type": "function"
},
{
"name": "assertIsInstance",
"type": "function"
},
{
"name": "assertIsNone",
"type": "function"
},
{
"name": "assertIsNot",
"type": "function"
},
{
"name": "assertIsNotNone",
"type": "function"
},
{
"name": "assertLess",
"type": "function"
},
{
"name": "assertLessEqual",
"type": "function"
},
{
"name": "assertListEqual",
"type": "function"
},
{
"name": "assertLogs",
"type": "function"
},
{
"name": "assertMultiLineEqual",
"type": "function"
},
{
"name": "assertNotAlmostEqual",
"type": "function"
},
{
"name": "assertNotAlmostEquals",
"type": "function"
},
{
"name": "assertNotEqual",
"type": "function"
},
{
"name": "assertNotEquals",
"type": "function"
},
{
"name": "assertNotIn",
"type": "function"
},
{
"name": "assertNotIsInstance",
"type": "function"
},
{
"name": "assertNotRegex",
"type": "function"
},
{
"name": "assertNotRegexpMatches",
"type": "function"
},
{
"name": "assertRaises",
"type": "function"
},
{
"name": "assertRaisesRegex",
"type": "function"
},
{
"name": "assertRaisesRegexp",
"type": "function"
},
{
"name": "assertRegex",
"type": "function"
},
{
"name": "assertRegexpMatches",
"type": "function"
},
{
"name": "assertSequenceEqual",
"type": "function"
},
{
"name": "assertSetEqual",
"type": "function"
},
{
"name": "assertTrue",
"type": "function"
},
{
"name": "assertTupleEqual",
"type": "function"
},
{
"name": "assertWarns",
"type": "function"
},
{
"name": "assertWarnsRegex",
"type": "function"
},
{
"name": "countTestCases",
"type": "function"
},
{
"name": "debug",
"type": "function"
},
{
"name": "defaultTestResult",
"type": "function"
},
{
"name": "doClassCleanups",
"type": "function"
},
{
"name": "doCleanups",
"type": "function"
},
{
"name": "engine",
"type": "statement"
},
{
"name": "fail",
"type": "function"
},
{
"name": "failIf",
"type": "function"
},
{
"name": "failIfAlmostEqual",
"type": "function"
},
{
"name": "failIfEqual",
"type": "function"
},
{
"name": "failUnless",
"type": "function"
},
{
"name": "failUnlessAlmostEqual",
"type": "function"
},
{
"name": "failUnlessEqual",
"type": "function"
},
{
"name": "failUnlessRaises",
"type": "function"
},
{
"name": "failureException",
"type": "statement"
},
{
"name": "id",
"type": "function"
},
{
"name": "longMessage",
"type": "statement"
},
{
"name": "maxDiff",
"type": "statement"
},
{
"name": "origin_function",
"type": "statement"
},
{
"name": "run",
"type": "function"
},
{
"name": "setUp",
"type": "function"
},
{
"name": "setUpClass",
"type": "function"
},
{
"name": "shortDescription",
"type": "function"
},
{
"name": "skipTest",
"type": "function"
},
{
"name": "subTest",
"type": "function"
},
{
"name": "tearDown",
"type": "function"
},
{
"name": "tearDownClass",
"type": "function"
},
{
"name": "test_validation_assert_column_exist",
"type": "function"
},
{
"name": "test_validation_assert_column_min_in_range",
"type": "function"
},
{
"name": "test_validation_assert_column_min_in_range_date",
"type": "function"
},
{
"name": "test_validation_assert_column_min_in_range_invalid_args",
"type": "function"
},
{
"name": "test_validation_assert_column_min_in_range_no_args",
"type": "function"
},
{
"name": "test_validation_assert_column_not_null",
"type": "function"
},
{
"name": "test_validation_assert_column_null",
"type": "function"
},
{
"name": "test_validation_assert_column_unique",
"type": "function"
},
{
"name": "test_validation_assert_row_count",
"type": "function"
},
{
"name": "test_validation_assert_row_count_in_range",
"type": "function"
},
{
"name": "test_validation_assert_row_count_in_range_invalid_args",
"type": "function"
},
{
"name": "test_validation_assert_row_count_in_range_no_args",
"type": "function"
},
{
"name": "test_validation_assert_row_count_invalid_args",
"type": "function"
},
{
"name": "_addSkip",
"type": "function"
},
{
"name": "_formatMessage",
"type": "function"
},
{
"name": "_getAssertEqualityFunc",
"type": "function"
},
{
"name": "_test_no_args_assertion",
"type": "function"
},
{
"name": "_testMethodDoc",
"type": "statement"
},
{
"name": "_testMethodName",
"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 io import StringIO
from unittest import TestCase
from ruamel import yaml
from piperider_cli.assertion_engine import AssertionEngine
def _(assertion_content: str):
def content_provider(self):
self.assertions_content = yaml.safe_load(StringIO(assertion_content))
return [], []
return content_provider
class BuiltinValidationTests(TestCase):
def setUp(self) -> None:
self.engine = AssertionEngine(None)
self.origin_function = AssertionEngine.load_assertion_content
def tearDown(self) -> None:
AssertionEngine.load_assertion_content = self.
|
[
"engine",
"assertEqual",
"assertListEqual",
"origin_function",
"setUp",
"tearDown",
"test_validation_assert_column_exist",
"test_validation_assert_column_min_in_range",
"test_validation_assert_column_min_in_range_date",
"test_validation_assert_column_min_in_range_invalid_args",
"test_validation_assert_column_min_in_range_no_args",
"test_validation_assert_column_not_null",
"test_validation_assert_column_null",
"test_validation_assert_column_unique",
"test_validation_assert_row_count",
"test_validation_assert_row_count_in_range",
"test_validation_assert_row_count_in_range_invalid_args",
"test_validation_assert_row_count_in_range_no_args",
"test_validation_assert_row_count_invalid_args",
"addClassCleanup",
"addCleanup",
"addTypeEqualityFunc",
"assert_",
"assertAlmostEqual",
"assertAlmostEquals",
"assertCountEqual",
"assertDictContainsSubset",
"assertDictEqual",
"assertEquals",
"assertFalse",
"assertGreater",
"assertGreaterEqual",
"assertIn",
"assertIs",
"assertIsInstance",
"assertIsNone",
"assertIsNot",
"assertIsNotNone",
"assertLess",
"assertLessEqual",
"assertLogs",
"assertMultiLineEqual",
"assertNoLogs",
"assertNotAlmostEqual",
"assertNotAlmostEquals",
"assertNotEqual",
"assertNotEquals",
"assertNotIn",
"assertNotIsInstance",
"assertNotRegex",
"assertNotRegexpMatches",
"assertRaises",
"assertRaisesRegex",
"assertRaisesRegexp",
"assertRegex",
"assertRegexpMatches",
"assertSequenceEqual",
"assertSetEqual",
"assertTrue",
"assertTupleEqual",
"assertWarns",
"assertWarnsRegex",
"countTestCases",
"debug",
"defaultTestResult",
"doClassCleanups",
"doCleanups",
"fail",
"failIf",
"failIfAlmostEqual",
"failIfEqual",
"failUnless",
"failUnlessAlmostEqual",
"failUnlessEqual",
"failUnlessRaises",
"failureException",
"id",
"longMessage",
"maxDiff",
"run",
"setUpClass",
"shortDescription",
"skipTest",
"subTest",
"tearDownClass"
] |
from io import StringIO
from unittest import TestCase
from ruamel import yaml
from piperider_cli.assertion_engine import AssertionEngine
def _(assertion_content: str):
def content_provider(self):
self.assertions_content = yaml.safe_load(StringIO(assertion_content))
return [], []
return content_provider
class BuiltinValidationTests(TestCase):
def setUp(self) -> None:
self.engine = AssertionEngine(None)
self.origin_function = AssertionEngine.load_assertion_content
def tearDown(self) -> None:
AssertionEngine.load_assertion_content = self.
| 1,366
|
2,110
| 43
| 4,015
|
infuseai__piperider
|
5047ef867db9d882cb61cdc4d9803b497ecf12e8
|
tests/test_builtin_validations.py
|
random
|
engine
| true
|
statement
| 86
| 90
| false
| false
|
[
"engine",
"assertEqual",
"test_validation_assert_row_count_in_range",
"test_validation_assert_column_min_in_range",
"test_validation_assert_row_count_in_range_invalid_args",
"_test_no_args_assertion",
"origin_function",
"setUp",
"tearDown",
"test_validation_assert_column_exist",
"test_validation_assert_column_min_in_range_date",
"test_validation_assert_column_min_in_range_invalid_args",
"test_validation_assert_column_min_in_range_no_args",
"test_validation_assert_column_not_null",
"test_validation_assert_column_null",
"test_validation_assert_column_unique",
"test_validation_assert_row_count",
"test_validation_assert_row_count_in_range_no_args",
"test_validation_assert_row_count_invalid_args",
"addClassCleanup",
"addCleanup",
"addTypeEqualityFunc",
"assert_",
"assertAlmostEqual",
"assertAlmostEquals",
"assertCountEqual",
"assertDictContainsSubset",
"assertDictEqual",
"assertEquals",
"assertFalse",
"assertGreater",
"assertGreaterEqual",
"assertIn",
"assertIs",
"assertIsInstance",
"assertIsNone",
"assertIsNot",
"assertIsNotNone",
"assertLess",
"assertLessEqual",
"assertListEqual",
"assertLogs",
"assertMultiLineEqual",
"assertNoLogs",
"assertNotAlmostEqual",
"assertNotAlmostEquals",
"assertNotEqual",
"assertNotEquals",
"assertNotIn",
"assertNotIsInstance",
"assertNotRegex",
"assertNotRegexpMatches",
"assertRaises",
"assertRaisesRegex",
"assertRaisesRegexp",
"assertRegex",
"assertRegexpMatches",
"assertSequenceEqual",
"assertSetEqual",
"assertTrue",
"assertTupleEqual",
"assertWarns",
"assertWarnsRegex",
"countTestCases",
"debug",
"defaultTestResult",
"doClassCleanups",
"doCleanups",
"fail",
"failIf",
"failIfAlmostEqual",
"failIfEqual",
"failUnless",
"failUnlessAlmostEqual",
"failUnlessEqual",
"failUnlessRaises",
"failureException",
"id",
"longMessage",
"maxDiff",
"run",
"setUpClass",
"shortDescription",
"skipTest",
"subTest",
"tearDownClass",
"__annotations__",
"__call__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "addClassCleanup",
"type": "function"
},
{
"name": "addCleanup",
"type": "function"
},
{
"name": "addTypeEqualityFunc",
"type": "function"
},
{
"name": "assert_",
"type": "function"
},
{
"name": "assertAlmostEqual",
"type": "function"
},
{
"name": "assertAlmostEquals",
"type": "function"
},
{
"name": "assertCountEqual",
"type": "function"
},
{
"name": "assertDictContainsSubset",
"type": "function"
},
{
"name": "assertDictEqual",
"type": "function"
},
{
"name": "assertEqual",
"type": "function"
},
{
"name": "assertEquals",
"type": "function"
},
{
"name": "assertFalse",
"type": "function"
},
{
"name": "assertGreater",
"type": "function"
},
{
"name": "assertGreaterEqual",
"type": "function"
},
{
"name": "assertIn",
"type": "function"
},
{
"name": "assertIs",
"type": "function"
},
{
"name": "assertIsInstance",
"type": "function"
},
{
"name": "assertIsNone",
"type": "function"
},
{
"name": "assertIsNot",
"type": "function"
},
{
"name": "assertIsNotNone",
"type": "function"
},
{
"name": "assertLess",
"type": "function"
},
{
"name": "assertLessEqual",
"type": "function"
},
{
"name": "assertListEqual",
"type": "function"
},
{
"name": "assertLogs",
"type": "function"
},
{
"name": "assertMultiLineEqual",
"type": "function"
},
{
"name": "assertNotAlmostEqual",
"type": "function"
},
{
"name": "assertNotAlmostEquals",
"type": "function"
},
{
"name": "assertNotEqual",
"type": "function"
},
{
"name": "assertNotEquals",
"type": "function"
},
{
"name": "assertNotIn",
"type": "function"
},
{
"name": "assertNotIsInstance",
"type": "function"
},
{
"name": "assertNotRegex",
"type": "function"
},
{
"name": "assertNotRegexpMatches",
"type": "function"
},
{
"name": "assertRaises",
"type": "function"
},
{
"name": "assertRaisesRegex",
"type": "function"
},
{
"name": "assertRaisesRegexp",
"type": "function"
},
{
"name": "assertRegex",
"type": "function"
},
{
"name": "assertRegexpMatches",
"type": "function"
},
{
"name": "assertSequenceEqual",
"type": "function"
},
{
"name": "assertSetEqual",
"type": "function"
},
{
"name": "assertTrue",
"type": "function"
},
{
"name": "assertTupleEqual",
"type": "function"
},
{
"name": "assertWarns",
"type": "function"
},
{
"name": "assertWarnsRegex",
"type": "function"
},
{
"name": "countTestCases",
"type": "function"
},
{
"name": "debug",
"type": "function"
},
{
"name": "defaultTestResult",
"type": "function"
},
{
"name": "doClassCleanups",
"type": "function"
},
{
"name": "doCleanups",
"type": "function"
},
{
"name": "engine",
"type": "statement"
},
{
"name": "fail",
"type": "function"
},
{
"name": "failIf",
"type": "function"
},
{
"name": "failIfAlmostEqual",
"type": "function"
},
{
"name": "failIfEqual",
"type": "function"
},
{
"name": "failUnless",
"type": "function"
},
{
"name": "failUnlessAlmostEqual",
"type": "function"
},
{
"name": "failUnlessEqual",
"type": "function"
},
{
"name": "failUnlessRaises",
"type": "function"
},
{
"name": "failureException",
"type": "statement"
},
{
"name": "id",
"type": "function"
},
{
"name": "longMessage",
"type": "statement"
},
{
"name": "maxDiff",
"type": "statement"
},
{
"name": "origin_function",
"type": "statement"
},
{
"name": "run",
"type": "function"
},
{
"name": "setUp",
"type": "function"
},
{
"name": "setUpClass",
"type": "function"
},
{
"name": "shortDescription",
"type": "function"
},
{
"name": "skipTest",
"type": "function"
},
{
"name": "subTest",
"type": "function"
},
{
"name": "tearDown",
"type": "function"
},
{
"name": "tearDownClass",
"type": "function"
},
{
"name": "test_validation_assert_column_exist",
"type": "function"
},
{
"name": "test_validation_assert_column_min_in_range",
"type": "function"
},
{
"name": "test_validation_assert_column_min_in_range_date",
"type": "function"
},
{
"name": "test_validation_assert_column_min_in_range_invalid_args",
"type": "function"
},
{
"name": "test_validation_assert_column_min_in_range_no_args",
"type": "function"
},
{
"name": "test_validation_assert_column_not_null",
"type": "function"
},
{
"name": "test_validation_assert_column_null",
"type": "function"
},
{
"name": "test_validation_assert_column_unique",
"type": "function"
},
{
"name": "test_validation_assert_row_count",
"type": "function"
},
{
"name": "test_validation_assert_row_count_in_range",
"type": "function"
},
{
"name": "test_validation_assert_row_count_in_range_invalid_args",
"type": "function"
},
{
"name": "test_validation_assert_row_count_in_range_no_args",
"type": "function"
},
{
"name": "test_validation_assert_row_count_invalid_args",
"type": "function"
},
{
"name": "_addSkip",
"type": "function"
},
{
"name": "_formatMessage",
"type": "function"
},
{
"name": "_getAssertEqualityFunc",
"type": "function"
},
{
"name": "_test_no_args_assertion",
"type": "function"
},
{
"name": "_testMethodDoc",
"type": "statement"
},
{
"name": "_testMethodName",
"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 io import StringIO
from unittest import TestCase
from ruamel import yaml
from piperider_cli.assertion_engine import AssertionEngine
def _(assertion_content: str):
def content_provider(self):
self.assertions_content = yaml.safe_load(StringIO(assertion_content))
return [], []
return content_provider
class BuiltinValidationTests(TestCase):
def setUp(self) -> None:
self.engine = AssertionEngine(None)
self.origin_function = AssertionEngine.load_assertion_content
def tearDown(self) -> None:
AssertionEngine.load_assertion_content = self.origin_function
def test_validation_assert_row_count_in_range(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count_in_range
assert:
count: [1000, 200000]
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
def test_validation_assert_row_count_in_range_no_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count_in_range
assert:
# it should be "count"
range: [1000, 200000]
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_row_count_in_range for table orders_1k
ERROR: count parameter is required
ERROR: count parameter should be a list""", results[0].as_internal_report())
def test_validation_assert_row_count_in_range_invalid_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count_in_range
assert:
count: [1000, 200000, 2]
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_row_count_in_range for table orders_1k
ERROR: count parameter should contain two values""", results[0].as_internal_report())
def test_validation_assert_row_count(self):
# test with valid format with min only
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
min: 10
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
# test with valid format with max only
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
max: 10
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.
|
[
"engine",
"assertEqual",
"test_validation_assert_row_count_in_range",
"test_validation_assert_column_min_in_range",
"test_validation_assert_row_count_in_range_invalid_args",
"origin_function",
"setUp",
"tearDown",
"test_validation_assert_column_exist",
"test_validation_assert_column_min_in_range_date",
"test_validation_assert_column_min_in_range_invalid_args",
"test_validation_assert_column_min_in_range_no_args",
"test_validation_assert_column_not_null",
"test_validation_assert_column_null",
"test_validation_assert_column_unique",
"test_validation_assert_row_count",
"test_validation_assert_row_count_in_range_no_args",
"test_validation_assert_row_count_invalid_args",
"addClassCleanup",
"addCleanup",
"addTypeEqualityFunc",
"assert_",
"assertAlmostEqual",
"assertAlmostEquals",
"assertCountEqual",
"assertDictContainsSubset",
"assertDictEqual",
"assertEquals",
"assertFalse",
"assertGreater",
"assertGreaterEqual",
"assertIn",
"assertIs",
"assertIsInstance",
"assertIsNone",
"assertIsNot",
"assertIsNotNone",
"assertLess",
"assertLessEqual",
"assertListEqual",
"assertLogs",
"assertMultiLineEqual",
"assertNoLogs",
"assertNotAlmostEqual",
"assertNotAlmostEquals",
"assertNotEqual",
"assertNotEquals",
"assertNotIn",
"assertNotIsInstance",
"assertNotRegex",
"assertNotRegexpMatches",
"assertRaises",
"assertRaisesRegex",
"assertRaisesRegexp",
"assertRegex",
"assertRegexpMatches",
"assertSequenceEqual",
"assertSetEqual",
"assertTrue",
"assertTupleEqual",
"assertWarns",
"assertWarnsRegex",
"countTestCases",
"debug",
"defaultTestResult",
"doClassCleanups",
"doCleanups",
"fail",
"failIf",
"failIfAlmostEqual",
"failIfEqual",
"failUnless",
"failUnlessAlmostEqual",
"failUnlessEqual",
"failUnlessRaises",
"failureException",
"id",
"longMessage",
"maxDiff",
"run",
"setUpClass",
"shortDescription",
"skipTest",
"subTest",
"tearDownClass"
] |
0].as_internal_report())
def test_validation_assert_row_count_in_range_invalid_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count_in_range
assert:
count: [1000, 200000, 2]
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_row_count_in_range for table orders_1k
ERROR: count parameter should contain two values""", results[0].as_internal_report())
def test_validation_assert_row_count(self):
# test with valid format with min only
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
min: 10
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
# test with valid format with max only
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
max: 10
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.
| 1,387
|
2,111
| 43
| 4,022
|
infuseai__piperider
|
5047ef867db9d882cb61cdc4d9803b497ecf12e8
|
tests/test_builtin_validations.py
|
random
|
validate_assertions
| true
|
function
| 20
| 24
| false
| false
|
[
"load_all_assertions_for_validation",
"validate_assertions",
"assertions_content",
"load_assertion_content",
"assertions",
"assertion_search_path",
"check_assertions_syntax",
"default_plugins_dir",
"evaluate",
"evaluate_all",
"generate_recommended_assertions",
"generate_template_assertions",
"load_assertions",
"load_plugins",
"PIPERIDER_ASSERTION_PLUGIN_PATH",
"PIPERIDER_ASSERTION_SEARCH_PATH",
"PIPERIDER_ASSERTION_SUPPORT_METRICS",
"PIPERIDER_WORKSPACE_NAME",
"profiler",
"recommender",
"__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": "assertion_search_path",
"type": "statement"
},
{
"name": "assertions",
"type": "statement"
},
{
"name": "assertions_content",
"type": "statement"
},
{
"name": "check_assertions_syntax",
"type": "function"
},
{
"name": "default_plugins_dir",
"type": "statement"
},
{
"name": "evaluate",
"type": "function"
},
{
"name": "evaluate_all",
"type": "function"
},
{
"name": "generate_recommended_assertions",
"type": "function"
},
{
"name": "generate_template_assertions",
"type": "function"
},
{
"name": "load_all_assertions_for_validation",
"type": "function"
},
{
"name": "load_assertion_content",
"type": "function"
},
{
"name": "load_assertions",
"type": "function"
},
{
"name": "load_plugins",
"type": "function"
},
{
"name": "PIPERIDER_ASSERTION_PLUGIN_PATH",
"type": "statement"
},
{
"name": "PIPERIDER_ASSERTION_SEARCH_PATH",
"type": "statement"
},
{
"name": "PIPERIDER_ASSERTION_SUPPORT_METRICS",
"type": "statement"
},
{
"name": "PIPERIDER_WORKSPACE_NAME",
"type": "statement"
},
{
"name": "profiler",
"type": "statement"
},
{
"name": "recommender",
"type": "statement"
},
{
"name": "validate_assertions",
"type": "function"
},
{
"name": "_backup_assertion_file",
"type": "function"
},
{
"name": "_dump_assertions_files",
"type": "function"
},
{
"name": "_recommend_assertion_filename",
"type": "function"
},
{
"name": "_update_existing_recommended_assertions",
"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"
}
] |
from io import StringIO
from unittest import TestCase
from ruamel import yaml
from piperider_cli.assertion_engine import AssertionEngine
def _(assertion_content: str):
def content_provider(self):
self.assertions_content = yaml.safe_load(StringIO(assertion_content))
return [], []
return content_provider
class BuiltinValidationTests(TestCase):
def setUp(self) -> None:
self.engine = AssertionEngine(None)
self.origin_function = AssertionEngine.load_assertion_content
def tearDown(self) -> None:
AssertionEngine.load_assertion_content = self.origin_function
def test_validation_assert_row_count_in_range(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count_in_range
assert:
count: [1000, 200000]
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
def test_validation_assert_row_count_in_range_no_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count_in_range
assert:
# it should be "count"
range: [1000, 200000]
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_row_count_in_range for table orders_1k
ERROR: count parameter is required
ERROR: count parameter should be a list""", results[0].as_internal_report())
def test_validation_assert_row_count_in_range_invalid_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count_in_range
assert:
count: [1000, 200000, 2]
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_row_count_in_range for table orders_1k
ERROR: count parameter should contain two values""", results[0].as_internal_report())
def test_validation_assert_row_count(self):
# test with valid format with min only
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
min: 10
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
# test with valid format with max only
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
max: 10
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.
|
[
"load_all_assertions_for_validation",
"validate_assertions",
"assertions_content",
"load_assertion_content",
"assertions",
"assertion_search_path",
"check_assertions_syntax",
"default_plugins_dir",
"evaluate",
"evaluate_all",
"generate_recommended_assertions",
"generate_template_assertions",
"load_assertions",
"load_plugins",
"PIPERIDER_ASSERTION_PLUGIN_PATH",
"PIPERIDER_ASSERTION_SEARCH_PATH",
"PIPERIDER_ASSERTION_SUPPORT_METRICS",
"PIPERIDER_WORKSPACE_NAME",
"profiler",
"recommender"
] |
nternal_report())
def test_validation_assert_row_count_in_range_invalid_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count_in_range
assert:
count: [1000, 200000, 2]
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_row_count_in_range for table orders_1k
ERROR: count parameter should contain two values""", results[0].as_internal_report())
def test_validation_assert_row_count(self):
# test with valid format with min only
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
min: 10
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
# test with valid format with max only
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
max: 10
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.
| 1,388
|
2,167
| 43
| 11,381
|
infuseai__piperider
|
5047ef867db9d882cb61cdc4d9803b497ecf12e8
|
tests/test_builtin_validations.py
|
random
|
engine
| true
|
statement
| 86
| 90
| false
| false
|
[
"engine",
"assertEqual",
"test_validation_assert_column_min_in_range",
"test_validation_assert_row_count_in_range",
"test_validation_assert_row_count",
"_test_no_args_assertion",
"origin_function",
"setUp",
"tearDown",
"test_validation_assert_column_exist",
"test_validation_assert_column_min_in_range_date",
"test_validation_assert_column_min_in_range_invalid_args",
"test_validation_assert_column_min_in_range_no_args",
"test_validation_assert_column_not_null",
"test_validation_assert_column_null",
"test_validation_assert_column_unique",
"test_validation_assert_row_count_in_range_invalid_args",
"test_validation_assert_row_count_in_range_no_args",
"test_validation_assert_row_count_invalid_args",
"addClassCleanup",
"addCleanup",
"addTypeEqualityFunc",
"assert_",
"assertAlmostEqual",
"assertAlmostEquals",
"assertCountEqual",
"assertDictContainsSubset",
"assertDictEqual",
"assertEquals",
"assertFalse",
"assertGreater",
"assertGreaterEqual",
"assertIn",
"assertIs",
"assertIsInstance",
"assertIsNone",
"assertIsNot",
"assertIsNotNone",
"assertLess",
"assertLessEqual",
"assertListEqual",
"assertLogs",
"assertMultiLineEqual",
"assertNoLogs",
"assertNotAlmostEqual",
"assertNotAlmostEquals",
"assertNotEqual",
"assertNotEquals",
"assertNotIn",
"assertNotIsInstance",
"assertNotRegex",
"assertNotRegexpMatches",
"assertRaises",
"assertRaisesRegex",
"assertRaisesRegexp",
"assertRegex",
"assertRegexpMatches",
"assertSequenceEqual",
"assertSetEqual",
"assertTrue",
"assertTupleEqual",
"assertWarns",
"assertWarnsRegex",
"countTestCases",
"debug",
"defaultTestResult",
"doClassCleanups",
"doCleanups",
"fail",
"failIf",
"failIfAlmostEqual",
"failIfEqual",
"failUnless",
"failUnlessAlmostEqual",
"failUnlessEqual",
"failUnlessRaises",
"failureException",
"id",
"longMessage",
"maxDiff",
"run",
"setUpClass",
"shortDescription",
"skipTest",
"subTest",
"tearDownClass",
"__annotations__",
"__call__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "addClassCleanup",
"type": "function"
},
{
"name": "addCleanup",
"type": "function"
},
{
"name": "addTypeEqualityFunc",
"type": "function"
},
{
"name": "assert_",
"type": "function"
},
{
"name": "assertAlmostEqual",
"type": "function"
},
{
"name": "assertAlmostEquals",
"type": "function"
},
{
"name": "assertCountEqual",
"type": "function"
},
{
"name": "assertDictContainsSubset",
"type": "function"
},
{
"name": "assertDictEqual",
"type": "function"
},
{
"name": "assertEqual",
"type": "function"
},
{
"name": "assertEquals",
"type": "function"
},
{
"name": "assertFalse",
"type": "function"
},
{
"name": "assertGreater",
"type": "function"
},
{
"name": "assertGreaterEqual",
"type": "function"
},
{
"name": "assertIn",
"type": "function"
},
{
"name": "assertIs",
"type": "function"
},
{
"name": "assertIsInstance",
"type": "function"
},
{
"name": "assertIsNone",
"type": "function"
},
{
"name": "assertIsNot",
"type": "function"
},
{
"name": "assertIsNotNone",
"type": "function"
},
{
"name": "assertLess",
"type": "function"
},
{
"name": "assertLessEqual",
"type": "function"
},
{
"name": "assertListEqual",
"type": "function"
},
{
"name": "assertLogs",
"type": "function"
},
{
"name": "assertMultiLineEqual",
"type": "function"
},
{
"name": "assertNotAlmostEqual",
"type": "function"
},
{
"name": "assertNotAlmostEquals",
"type": "function"
},
{
"name": "assertNotEqual",
"type": "function"
},
{
"name": "assertNotEquals",
"type": "function"
},
{
"name": "assertNotIn",
"type": "function"
},
{
"name": "assertNotIsInstance",
"type": "function"
},
{
"name": "assertNotRegex",
"type": "function"
},
{
"name": "assertNotRegexpMatches",
"type": "function"
},
{
"name": "assertRaises",
"type": "function"
},
{
"name": "assertRaisesRegex",
"type": "function"
},
{
"name": "assertRaisesRegexp",
"type": "function"
},
{
"name": "assertRegex",
"type": "function"
},
{
"name": "assertRegexpMatches",
"type": "function"
},
{
"name": "assertSequenceEqual",
"type": "function"
},
{
"name": "assertSetEqual",
"type": "function"
},
{
"name": "assertTrue",
"type": "function"
},
{
"name": "assertTupleEqual",
"type": "function"
},
{
"name": "assertWarns",
"type": "function"
},
{
"name": "assertWarnsRegex",
"type": "function"
},
{
"name": "countTestCases",
"type": "function"
},
{
"name": "debug",
"type": "function"
},
{
"name": "defaultTestResult",
"type": "function"
},
{
"name": "doClassCleanups",
"type": "function"
},
{
"name": "doCleanups",
"type": "function"
},
{
"name": "engine",
"type": "statement"
},
{
"name": "fail",
"type": "function"
},
{
"name": "failIf",
"type": "function"
},
{
"name": "failIfAlmostEqual",
"type": "function"
},
{
"name": "failIfEqual",
"type": "function"
},
{
"name": "failUnless",
"type": "function"
},
{
"name": "failUnlessAlmostEqual",
"type": "function"
},
{
"name": "failUnlessEqual",
"type": "function"
},
{
"name": "failUnlessRaises",
"type": "function"
},
{
"name": "failureException",
"type": "statement"
},
{
"name": "id",
"type": "function"
},
{
"name": "longMessage",
"type": "statement"
},
{
"name": "maxDiff",
"type": "statement"
},
{
"name": "origin_function",
"type": "statement"
},
{
"name": "run",
"type": "function"
},
{
"name": "setUp",
"type": "function"
},
{
"name": "setUpClass",
"type": "function"
},
{
"name": "shortDescription",
"type": "function"
},
{
"name": "skipTest",
"type": "function"
},
{
"name": "subTest",
"type": "function"
},
{
"name": "tearDown",
"type": "function"
},
{
"name": "tearDownClass",
"type": "function"
},
{
"name": "test_validation_assert_column_exist",
"type": "function"
},
{
"name": "test_validation_assert_column_min_in_range",
"type": "function"
},
{
"name": "test_validation_assert_column_min_in_range_date",
"type": "function"
},
{
"name": "test_validation_assert_column_min_in_range_invalid_args",
"type": "function"
},
{
"name": "test_validation_assert_column_min_in_range_no_args",
"type": "function"
},
{
"name": "test_validation_assert_column_not_null",
"type": "function"
},
{
"name": "test_validation_assert_column_null",
"type": "function"
},
{
"name": "test_validation_assert_column_unique",
"type": "function"
},
{
"name": "test_validation_assert_row_count",
"type": "function"
},
{
"name": "test_validation_assert_row_count_in_range",
"type": "function"
},
{
"name": "test_validation_assert_row_count_in_range_invalid_args",
"type": "function"
},
{
"name": "test_validation_assert_row_count_in_range_no_args",
"type": "function"
},
{
"name": "test_validation_assert_row_count_invalid_args",
"type": "function"
},
{
"name": "_addSkip",
"type": "function"
},
{
"name": "_formatMessage",
"type": "function"
},
{
"name": "_getAssertEqualityFunc",
"type": "function"
},
{
"name": "_test_no_args_assertion",
"type": "function"
},
{
"name": "_testMethodDoc",
"type": "statement"
},
{
"name": "_testMethodName",
"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 io import StringIO
from unittest import TestCase
from ruamel import yaml
from piperider_cli.assertion_engine import AssertionEngine
def _(assertion_content: str):
def content_provider(self):
self.assertions_content = yaml.safe_load(StringIO(assertion_content))
return [], []
return content_provider
class BuiltinValidationTests(TestCase):
def setUp(self) -> None:
self.engine = AssertionEngine(None)
self.origin_function = AssertionEngine.load_assertion_content
def tearDown(self) -> None:
AssertionEngine.load_assertion_content = self.origin_function
def test_validation_assert_row_count_in_range(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count_in_range
assert:
count: [1000, 200000]
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
def test_validation_assert_row_count_in_range_no_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count_in_range
assert:
# it should be "count"
range: [1000, 200000]
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_row_count_in_range for table orders_1k
ERROR: count parameter is required
ERROR: count parameter should be a list""", results[0].as_internal_report())
def test_validation_assert_row_count_in_range_invalid_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count_in_range
assert:
count: [1000, 200000, 2]
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_row_count_in_range for table orders_1k
ERROR: count parameter should contain two values""", results[0].as_internal_report())
def test_validation_assert_row_count(self):
# test with valid format with min only
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
min: 10
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
# test with valid format with max only
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
max: 10
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
# test with valid format with min and max
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
min: 10
max: 100
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
def test_validation_assert_row_count_invalid_args(self):
# test with invalid syntax
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
x: 10
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_row_count for table orders_1k
ERROR: There should contain any parameter names in ['min', 'max']""", results[0].as_internal_report())
# test with invalid syntax: max < min
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
min: 100
max: 1
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_row_count for table orders_1k
ERROR: The max value should be greater than or equal to the min value.""", results[0].as_internal_report())
# test with invalid syntax: not int
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
min: 1.0
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_row_count for table orders_1k
ERROR: min parameter should be a int value""", results[0].as_internal_report())
def test_validation_assert_column_not_null(self):
self._test_no_args_assertion('assert_column_not_null')
def test_validation_assert_column_null(self):
self._test_no_args_assertion('assert_column_null')
def test_validation_assert_column_unique(self):
self._test_no_args_assertion('assert_column_unique')
def test_validation_assert_column_exist(self):
self._test_no_args_assertion('assert_column_exist')
def _test_no_args_assertion(self, function_name):
# test with no problem syntax
AssertionEngine.load_assertion_content = _(f"""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: {function_name}
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
# test with error syntax
AssertionEngine.load_assertion_content = _(f"""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: {function_name}
assert:
foo: bar
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual(f"""Found assertion syntax problem => name: {function_name} for table orders_1k and column foobarbar
ERROR: parameters are not allowed""", results[0].as_internal_report())
def test_validation_assert_column_min_in_range(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: assert_column_min_in_range
assert:
min: [10, 30]
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
def test_validation_assert_column_min_in_range_date(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: assert_column_min_in_range
assert:
min: [2022-05-20, 2022-05-31]
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
def test_validation_assert_column_min_in_range_no_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: assert_column_min_in_range
assert:
# it should be "min"
max: [10, 100]
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_column_min_in_range for table orders_1k and column foobarbar
ERROR: min parameter is required""", results[0].as_internal_report())
def test_validation_assert_column_min_in_range_invalid_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: assert_column_min_in_range
assert:
min: [10, 2022-05-23]
""")
# expect no errors and warnings
self.
|
[
"engine",
"assertEqual",
"test_validation_assert_column_min_in_range",
"test_validation_assert_row_count_in_range",
"test_validation_assert_row_count",
"origin_function",
"setUp",
"tearDown",
"test_validation_assert_column_exist",
"test_validation_assert_column_min_in_range_date",
"test_validation_assert_column_min_in_range_invalid_args",
"test_validation_assert_column_min_in_range_no_args",
"test_validation_assert_column_not_null",
"test_validation_assert_column_null",
"test_validation_assert_column_unique",
"test_validation_assert_row_count_in_range_invalid_args",
"test_validation_assert_row_count_in_range_no_args",
"test_validation_assert_row_count_invalid_args",
"addClassCleanup",
"addCleanup",
"addTypeEqualityFunc",
"assert_",
"assertAlmostEqual",
"assertAlmostEquals",
"assertCountEqual",
"assertDictContainsSubset",
"assertDictEqual",
"assertEquals",
"assertFalse",
"assertGreater",
"assertGreaterEqual",
"assertIn",
"assertIs",
"assertIsInstance",
"assertIsNone",
"assertIsNot",
"assertIsNotNone",
"assertLess",
"assertLessEqual",
"assertListEqual",
"assertLogs",
"assertMultiLineEqual",
"assertNoLogs",
"assertNotAlmostEqual",
"assertNotAlmostEquals",
"assertNotEqual",
"assertNotEquals",
"assertNotIn",
"assertNotIsInstance",
"assertNotRegex",
"assertNotRegexpMatches",
"assertRaises",
"assertRaisesRegex",
"assertRaisesRegexp",
"assertRegex",
"assertRegexpMatches",
"assertSequenceEqual",
"assertSetEqual",
"assertTrue",
"assertTupleEqual",
"assertWarns",
"assertWarnsRegex",
"countTestCases",
"debug",
"defaultTestResult",
"doClassCleanups",
"doCleanups",
"fail",
"failIf",
"failIfAlmostEqual",
"failIfEqual",
"failUnless",
"failUnlessAlmostEqual",
"failUnlessEqual",
"failUnlessRaises",
"failureException",
"id",
"longMessage",
"maxDiff",
"run",
"setUpClass",
"shortDescription",
"skipTest",
"subTest",
"tearDownClass"
] |
ine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: assert_column_min_in_range
assert:
min: [2022-05-20, 2022-05-31]
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
def test_validation_assert_column_min_in_range_no_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: assert_column_min_in_range
assert:
# it should be "min"
max: [10, 100]
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_column_min_in_range for table orders_1k and column foobarbar
ERROR: min parameter is required""", results[0].as_internal_report())
def test_validation_assert_column_min_in_range_invalid_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: assert_column_min_in_range
assert:
min: [10, 2022-05-23]
""")
# expect no errors and warnings
self.
| 1,434
|
2,168
| 43
| 11,388
|
infuseai__piperider
|
5047ef867db9d882cb61cdc4d9803b497ecf12e8
|
tests/test_builtin_validations.py
|
random
|
load_all_assertions_for_validation
| true
|
function
| 20
| 24
| false
| false
|
[
"validate_assertions",
"load_all_assertions_for_validation",
"assertions_content",
"load_assertion_content",
"assertions",
"assertion_search_path",
"check_assertions_syntax",
"default_plugins_dir",
"evaluate",
"evaluate_all",
"generate_recommended_assertions",
"generate_template_assertions",
"load_assertions",
"load_plugins",
"PIPERIDER_ASSERTION_PLUGIN_PATH",
"PIPERIDER_ASSERTION_SEARCH_PATH",
"PIPERIDER_ASSERTION_SUPPORT_METRICS",
"PIPERIDER_WORKSPACE_NAME",
"profiler",
"recommender",
"__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": "assertion_search_path",
"type": "statement"
},
{
"name": "assertions",
"type": "statement"
},
{
"name": "assertions_content",
"type": "statement"
},
{
"name": "check_assertions_syntax",
"type": "function"
},
{
"name": "default_plugins_dir",
"type": "statement"
},
{
"name": "evaluate",
"type": "function"
},
{
"name": "evaluate_all",
"type": "function"
},
{
"name": "generate_recommended_assertions",
"type": "function"
},
{
"name": "generate_template_assertions",
"type": "function"
},
{
"name": "load_all_assertions_for_validation",
"type": "function"
},
{
"name": "load_assertion_content",
"type": "function"
},
{
"name": "load_assertions",
"type": "function"
},
{
"name": "load_plugins",
"type": "function"
},
{
"name": "PIPERIDER_ASSERTION_PLUGIN_PATH",
"type": "statement"
},
{
"name": "PIPERIDER_ASSERTION_SEARCH_PATH",
"type": "statement"
},
{
"name": "PIPERIDER_ASSERTION_SUPPORT_METRICS",
"type": "statement"
},
{
"name": "PIPERIDER_WORKSPACE_NAME",
"type": "statement"
},
{
"name": "profiler",
"type": "statement"
},
{
"name": "recommender",
"type": "statement"
},
{
"name": "validate_assertions",
"type": "function"
},
{
"name": "_backup_assertion_file",
"type": "function"
},
{
"name": "_dump_assertions_files",
"type": "function"
},
{
"name": "_recommend_assertion_filename",
"type": "function"
},
{
"name": "_update_existing_recommended_assertions",
"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"
}
] |
from io import StringIO
from unittest import TestCase
from ruamel import yaml
from piperider_cli.assertion_engine import AssertionEngine
def _(assertion_content: str):
def content_provider(self):
self.assertions_content = yaml.safe_load(StringIO(assertion_content))
return [], []
return content_provider
class BuiltinValidationTests(TestCase):
def setUp(self) -> None:
self.engine = AssertionEngine(None)
self.origin_function = AssertionEngine.load_assertion_content
def tearDown(self) -> None:
AssertionEngine.load_assertion_content = self.origin_function
def test_validation_assert_row_count_in_range(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count_in_range
assert:
count: [1000, 200000]
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
def test_validation_assert_row_count_in_range_no_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count_in_range
assert:
# it should be "count"
range: [1000, 200000]
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_row_count_in_range for table orders_1k
ERROR: count parameter is required
ERROR: count parameter should be a list""", results[0].as_internal_report())
def test_validation_assert_row_count_in_range_invalid_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count_in_range
assert:
count: [1000, 200000, 2]
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_row_count_in_range for table orders_1k
ERROR: count parameter should contain two values""", results[0].as_internal_report())
def test_validation_assert_row_count(self):
# test with valid format with min only
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
min: 10
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
# test with valid format with max only
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
max: 10
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
# test with valid format with min and max
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
min: 10
max: 100
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
def test_validation_assert_row_count_invalid_args(self):
# test with invalid syntax
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
x: 10
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_row_count for table orders_1k
ERROR: There should contain any parameter names in ['min', 'max']""", results[0].as_internal_report())
# test with invalid syntax: max < min
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
min: 100
max: 1
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_row_count for table orders_1k
ERROR: The max value should be greater than or equal to the min value.""", results[0].as_internal_report())
# test with invalid syntax: not int
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
tests:
- name: assert_row_count
assert:
min: 1.0
tags:
- OPTIONAL
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_row_count for table orders_1k
ERROR: min parameter should be a int value""", results[0].as_internal_report())
def test_validation_assert_column_not_null(self):
self._test_no_args_assertion('assert_column_not_null')
def test_validation_assert_column_null(self):
self._test_no_args_assertion('assert_column_null')
def test_validation_assert_column_unique(self):
self._test_no_args_assertion('assert_column_unique')
def test_validation_assert_column_exist(self):
self._test_no_args_assertion('assert_column_exist')
def _test_no_args_assertion(self, function_name):
# test with no problem syntax
AssertionEngine.load_assertion_content = _(f"""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: {function_name}
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
# test with error syntax
AssertionEngine.load_assertion_content = _(f"""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: {function_name}
assert:
foo: bar
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual(f"""Found assertion syntax problem => name: {function_name} for table orders_1k and column foobarbar
ERROR: parameters are not allowed""", results[0].as_internal_report())
def test_validation_assert_column_min_in_range(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: assert_column_min_in_range
assert:
min: [10, 30]
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
def test_validation_assert_column_min_in_range_date(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: assert_column_min_in_range
assert:
min: [2022-05-20, 2022-05-31]
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
def test_validation_assert_column_min_in_range_no_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: assert_column_min_in_range
assert:
# it should be "min"
max: [10, 100]
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_column_min_in_range for table orders_1k and column foobarbar
ERROR: min parameter is required""", results[0].as_internal_report())
def test_validation_assert_column_min_in_range_invalid_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: assert_column_min_in_range
assert:
min: [10, 2022-05-23]
""")
# expect no errors and warnings
self.engine.
|
[
"validate_assertions",
"load_all_assertions_for_validation",
"assertions_content",
"load_assertion_content",
"assertions",
"assertion_search_path",
"check_assertions_syntax",
"default_plugins_dir",
"evaluate",
"evaluate_all",
"generate_recommended_assertions",
"generate_template_assertions",
"load_assertions",
"load_plugins",
"PIPERIDER_ASSERTION_PLUGIN_PATH",
"PIPERIDER_ASSERTION_SEARCH_PATH",
"PIPERIDER_ASSERTION_SUPPORT_METRICS",
"PIPERIDER_WORKSPACE_NAME",
"profiler",
"recommender"
] |
d_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: assert_column_min_in_range
assert:
min: [2022-05-20, 2022-05-31]
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertListEqual([], results)
def test_validation_assert_column_min_in_range_no_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: assert_column_min_in_range
assert:
# it should be "min"
max: [10, 100]
""")
# expect no errors and warnings
self.engine.load_all_assertions_for_validation()
results = self.engine.validate_assertions()
self.assertEqual(1, len(results))
self.assertEqual("""Found assertion syntax problem => name: assert_column_min_in_range for table orders_1k and column foobarbar
ERROR: min parameter is required""", results[0].as_internal_report())
def test_validation_assert_column_min_in_range_invalid_args(self):
# test with valid format
AssertionEngine.load_assertion_content = _("""
orders_1k: # Table Name
# Test Cases for Table
columns:
foobarbar:
tests:
- name: assert_column_min_in_range
assert:
min: [10, 2022-05-23]
""")
# expect no errors and warnings
self.engine.
| 1,435
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.