Search is not available for this dataset
text stringlengths 75 104k |
|---|
def package_for_editor_signavio(self, spec, filename):
"""
Adds the SVG files to the archive for this BPMN file.
"""
signavio_file = filename[:-len('.bpmn20.xml')] + '.signavio.xml'
if os.path.exists(signavio_file):
self.write_file_to_package_zip(
"src... |
def write_meta_data(self):
"""
Writes the metadata.ini file to the archive.
"""
config = configparser.ConfigParser()
config.add_section('MetaData')
config.set('MetaData', 'entry_point_process', self.wf_spec.name)
if self.editor:
config.set('MetaData',... |
def add_main_options(cls, parser):
"""
Override in subclass if required.
"""
parser.add_option("-o", "--output", dest="package_file",
help="create the BPMN package in the specified file")
parser.add_option("-p", "--process", dest="entry_point_process",
... |
def add_additional_options(cls, parser):
"""
Override in subclass if required.
"""
group = OptionGroup(parser, "Target Engine Options",
"These options are not required, but may be "
"provided if a specific "
... |
def check_args(cls, config, options, args, parser, package_file=None):
"""
Override in subclass if required.
"""
if not args:
parser.error("no input files specified")
if not (package_file or options.package_file):
parser.error("no package file specified")
... |
def merge_options_and_config(cls, config, options, args):
"""
Override in subclass if required.
"""
if args:
config.set(CONFIG_SECTION_NAME, 'input_files', ','.join(args))
elif config.has_option(CONFIG_SECTION_NAME, 'input_files'):
for i in config.get(CONF... |
def merge_option_and_config_str(cls, option_name, config, options):
"""
Utility method to merge an option and config, with the option taking "
precedence
"""
opt = getattr(options, option_name, None)
if opt:
config.set(CONFIG_SECTION_NAME, option_name, opt)
... |
def create_meta_data(cls, options, args, parser):
"""
Override in subclass if required.
"""
meta_data = []
meta_data.append(('spiff_version', cls.get_version()))
if options.target_engine:
meta_data.append(('target_engine', options.target_engine))
if op... |
def parse_node(self, node):
"""
Parses the specified child task node, and returns the task spec. This
can be called by a TaskParser instance, that is owned by this
ProcessParser.
"""
if node.get('id') in self.parsed_nodes:
return self.parsed_nodes[node.get('i... |
def get_spec(self):
"""
Parse this process (if it has not already been parsed), and return the
workflow spec.
"""
if self.is_parsed:
return self.spec
if self.parsing_started:
raise NotImplementedError(
'Recursive call Activities are... |
def _on_trigger(self, task_spec):
"""
May be called after execute() was already completed to create an
additional outbound task.
"""
# Find a Task for this TaskSpec.
my_task = self._find_my_task(task_spec)
if my_task._has_state(Task.COMPLETED):
state =... |
def connect(self, task_spec):
"""
Connect the *following* task to this one. In other words, the
given task is added as an output task.
task -- the task to connect to.
"""
self.thread_starter.outputs.append(task_spec)
task_spec._connect_notify(self.thread_starter) |
def _get_activated_tasks(self, my_task, destination):
"""
Returns the list of tasks that were activated in the previous
call of execute(). Only returns tasks that point towards the
destination task, i.e. those which have destination as a
descendant.
my_task -- the task o... |
def _on_trigger(self, my_task):
"""
May be called after execute() was already completed to create an
additional outbound task.
"""
for output in self.outputs:
new_task = my_task.add_child(output, Task.READY)
new_task.triggered = True |
def deserialize_assign(self, workflow, start_node):
"""
Reads the "pre-assign" or "post-assign" tag from the given node.
start_node -- the xml node (xml.dom.minidom.Node)
"""
name = start_node.getAttribute('name')
attrib = start_node.getAttribute('field')
value =... |
def deserialize_data(self, workflow, start_node):
"""
Reads a "data" or "define" tag from the given node.
start_node -- the xml node (xml.dom.minidom.Node)
"""
name = start_node.getAttribute('name')
value = start_node.getAttribute('value')
return name, value |
def deserialize_assign_list(self, workflow, start_node):
"""
Reads a list of assignments from the given node.
workflow -- the workflow
start_node -- the xml structure (xml.dom.minidom.Node)
"""
# Collect all information.
assignments = []
for node in start... |
def deserialize_logical(self, node):
"""
Reads the logical tag from the given node, returns a Condition object.
node -- the xml node (xml.dom.minidom.Node)
"""
term1_attrib = node.getAttribute('left-field')
term1_value = node.getAttribute('left-value')
op = node.... |
def deserialize_condition(self, workflow, start_node):
"""
Reads the conditional statement from the given node.
workflow -- the workflow with which the concurrence is associated
start_node -- the xml structure (xml.dom.minidom.Node)
"""
# Collect all information.
... |
def deserialize_task_spec(self, workflow, start_node, read_specs):
"""
Reads the task from the given node and returns a tuple
(start, end) that contains the stream of objects that model
the behavior.
workflow -- the workflow with which the task is associated
start_node -... |
def deserialize_workflow_spec(self, s_state, filename=None):
"""
Reads the workflow from the given XML structure and returns a
WorkflowSpec instance.
"""
dom = minidom.parseString(s_state)
node = dom.getElementsByTagName('process-definition')[0]
name = node.getAtt... |
def has_fired(self, my_task):
"""
The Timer is considered to have fired if the evaluated dateTime
expression is before datetime.datetime.now()
"""
dt = my_task.workflow.script_engine.evaluate(my_task, self.dateTime)
if dt is None:
return False
if dt.tz... |
def _add_notify(self, task_spec):
"""
Called by a task spec when it was added into the workflow.
"""
if task_spec.name in self.task_specs:
raise KeyError('Duplicate task spec name: ' + task_spec.name)
self.task_specs[task_spec.name] = task_spec
task_spec.id = ... |
def validate(self):
"""Checks integrity of workflow and reports any problems with it.
Detects:
- loops (tasks that wait on each other in a loop)
:returns: empty list if valid, a list of errors if not
"""
results = []
from ..specs import Join
def recursiv... |
def accept_message(self, message):
"""
Indicate to the workflow that a message has been received. The message
will be processed by any waiting Intermediate or Boundary Message
Events, that are waiting for the message.
"""
assert not self.read_only
self.refresh_wai... |
def do_engine_steps(self):
"""
Execute any READY tasks that are engine specific (for example, gateways
or script tasks). This is done in a loop, so it will keep completing
those tasks until there are only READY User tasks, or WAITING tasks
left.
"""
assert not sel... |
def refresh_waiting_tasks(self):
"""
Refresh the state of all WAITING tasks. This will, for example, update
Catching Timer Events whose waiting time has passed.
"""
assert not self.read_only
for my_task in self.get_tasks(Task.WAITING):
my_task.task_spec._updat... |
def get_ready_user_tasks(self):
"""
Returns a list of User Tasks that are READY for user action
"""
return [t for t in self.get_tasks(Task.READY)
if not self._is_engine_task(t.task_spec)] |
def _on_trigger(self, my_task):
"""
Enqueue a trigger, such that this tasks triggers multiple times later
when _on_complete() is called.
"""
self.queued += 1
# All tasks that have already completed need to be put back to
# READY.
for thetask in my_task.wor... |
def _on_complete_hook(self, my_task):
"""
A hook into _on_complete() that does the task specific work.
:type my_task: Task
:param my_task: A task in which this method is executed.
:rtype: bool
:returns: True on success, False otherwise.
"""
times = int(... |
def deserialize(cls, serializer, wf_spec, s_state, **kwargs):
"""
Deserializes the trigger using the provided serializer.
"""
return serializer.deserialize_trigger(wf_spec,
s_state,
**kwargs) |
def evaluate(self, task, expression):
"""
Evaluate the given expression, within the context of the given task and
return the result.
"""
if isinstance(expression, Operator):
return expression._matches(task)
else:
return self._eval(task, expression,... |
def execute(self, task, script, **kwargs):
"""
Execute the script, within the context of the specified task
"""
locals().update(kwargs)
exec(script) |
def merge_dictionary(dst, src):
"""Recursive merge two dicts (vs .update which overwrites the hashes at the
root level)
Note: This updates dst.
Copied from checkmate.utils
"""
stack = [(dst, src)]
while stack:
current_dst, current_src = stack.pop()
for key in current_src:
... |
def _start(self, my_task, force=False):
"""
Checks whether the preconditions for going to READY state are met.
Returns True if the threshold was reached, False otherwise.
Also returns the list of tasks that yet need to be completed.
"""
# If the threshold was already reac... |
def _on_trigger(self, my_task):
"""
May be called to fire the Join before the incoming branches are
completed.
"""
for task in my_task.workflow.task_tree._find_any(self):
if task.thread_id != my_task.thread_id:
continue
self._do_join(task) |
def connect(self, task_spec):
"""
Connects the task spec that is executed if no other condition
matches.
:type task_spec: TaskSpec
:param task_spec: The following task spec.
"""
assert self.default_task_spec is None
self.outputs.append(task_spec)
... |
def container_id(self, name):
'''Try to find the container ID with the specified name'''
container = self._containers.get(name, None)
if not container is None:
return container.get('id', None)
return None |
def initialize(self, containers):
'''
Initialize a new state file with the given contents.
This function fails in case the state file already exists.
'''
self._containers = deepcopy(containers)
self.__write(containers, initialize=True) |
def update(self, containers):
'''Update the current state file with the specified contents'''
self._containers = deepcopy(containers)
self.__write(containers, initialize=False) |
def load(self):
'''Try to load a blockade state file in the current directory'''
try:
with open(self._state_file) as f:
state = yaml.safe_load(f)
self._containers = state['containers']
except (IOError, OSError) as err:
if err.errno == errno... |
def _get_blockade_id_from_cwd(self, cwd=None):
'''Generate a new blockade ID based on the CWD'''
if not cwd:
cwd = os.getcwd()
# this follows a similar pattern as docker-compose uses
parent_dir = os.path.abspath(cwd)
basename = os.path.basename(parent_dir).lower()
... |
def _assure_dir(self):
'''Make sure the state directory exists'''
try:
os.makedirs(self._state_dir)
except OSError as err:
if err.errno != errno.EEXIST:
raise |
def _state_delete(self):
'''Try to delete the state.yml file and the folder .blockade'''
try:
os.remove(self._state_file)
except OSError as err:
if err.errno not in (errno.EPERM, errno.ENOENT):
raise
try:
os.rmdir(self._state_dir)
... |
def __base_state(self, containers):
'''
Convert blockade ID and container information into
a state dictionary object.
'''
return dict(blockade_id=self._blockade_id,
containers=containers,
version=self._state_version) |
def __write(self, containers, initialize=True):
'''Write the given state information into a file'''
path = self._state_file
self._assure_dir()
try:
flags = os.O_WRONLY | os.O_CREAT
if initialize:
flags |= os.O_EXCL
with os.fdopen(os.ope... |
def expand_partitions(containers, partitions):
'''
Validate the partitions of containers. If there are any containers
not in any partition, place them in an new partition.
'''
# filter out holy containers that don't belong
# to any partition at all
all_names = frozenset(c.name for c in cont... |
def get_source_chains(self, blockade_id):
"""Get a map of blockade chains IDs -> list of IPs targeted at them
For figuring out which container is in which partition
"""
result = {}
if not blockade_id:
raise ValueError("invalid blockade_id")
lines = self.get_c... |
def insert_rule(self, chain, src=None, dest=None, target=None):
"""Insert a new rule in the chain
"""
if not chain:
raise ValueError("Invalid chain")
if not target:
raise ValueError("Invalid target")
if not (src or dest):
raise ValueError("Need... |
def _sm_start(self, *args, **kwargs):
"""
Start the timer waiting for pain
"""
millisec = random.randint(self._start_min_delay, self._start_max_delay)
self._timer = threading.Timer(millisec / 1000.0, self.event_timeout)
self._timer.start() |
def _sm_to_pain(self, *args, **kwargs):
"""
Start the blockade event
"""
_logger.info("Starting chaos for blockade %s" % self._blockade_name)
self._do_blockade_event()
# start the timer to end the pain
millisec = random.randint(self._run_min_time, self._run_max_ti... |
def _sm_stop_from_no_pain(self, *args, **kwargs):
"""
Stop chaos when there is no current blockade operation
"""
# Just stop the timer. It is possible that it was too late and the
# timer is about to run
_logger.info("Stopping chaos for blockade %s" % self._blockade_name... |
def _sm_relieve_pain(self, *args, **kwargs):
"""
End the blockade event and return to a steady state
"""
_logger.info(
"Ending the degradation for blockade %s" % self._blockade_name)
self._do_reset_all()
# set a timer for the next pain event
millis... |
def _sm_stop_from_pain(self, *args, **kwargs):
"""
Stop chaos while there is a blockade event in progress
"""
_logger.info("Stopping chaos for blockade %s" % self._blockade_name)
self._do_reset_all() |
def _sm_cleanup(self, *args, **kwargs):
"""
Delete all state associated with the chaos session
"""
if self._done_notification_func is not None:
self._done_notification_func()
self._timer.cancel() |
def dependency_sorted(containers):
"""Sort a dictionary or list of containers into dependency order
Returns a sequence
"""
if not isinstance(containers, collections.Mapping):
containers = dict((c.name, c) for c in containers)
container_links = dict((name, set(c.links.keys()))
... |
def from_dict(name, values):
'''
Convert a dictionary of configuration values
into a sequence of BlockadeContainerConfig instances
'''
# determine the number of instances of this container
count = 1
count_value = values.get('count', 1)
if isinstance(count... |
def from_dict(values):
'''
Instantiate a BlockadeConfig instance based on
a given dictionary of configuration values
'''
try:
containers = values['containers']
parsed_containers = {}
for name, container_dict in containers.items():
... |
def cmd_up(opts):
"""Start the containers and link them together
"""
config = load_config(opts.config)
b = get_blockade(config, opts)
containers = b.create(verbose=opts.verbose, force=opts.force)
print_containers(containers, opts.json) |
def cmd_destroy(opts):
"""Destroy all containers and restore networks
"""
config = load_config(opts.config)
b = get_blockade(config, opts)
b.destroy() |
def cmd_status(opts):
"""Print status of containers and networks
"""
config = load_config(opts.config)
b = get_blockade(config, opts)
containers = b.status()
print_containers(containers, opts.json) |
def cmd_kill(opts):
"""Kill some or all containers
"""
kill_signal = opts.signal if hasattr(opts, 'signal') else "SIGKILL"
__with_containers(opts, Blockade.kill, signal=kill_signal) |
def cmd_partition(opts):
"""Partition the network between containers
Replaces any existing partitions outright. Any containers NOT specified
in arguments will be globbed into a single implicit partition. For
example if you have three containers: c1, c2, and c3 and you run:
blockade partition c... |
def cmd_join(opts):
"""Restore full networking between containers
"""
config = load_config(opts.config)
b = get_blockade(config, opts)
b.join() |
def cmd_logs(opts):
"""Fetch the logs of a container
"""
config = load_config(opts.config)
b = get_blockade(config, opts)
puts(b.logs(opts.container).decode(encoding='UTF-8')) |
def cmd_daemon(opts):
"""Start the Blockade REST API
"""
if opts.data_dir is None:
raise BlockadeError("You must supply a data directory for the daemon")
rest.start(data_dir=opts.data_dir, port=opts.port, debug=opts.debug,
host_exec=get_host_exec()) |
def cmd_add(opts):
"""Add one or more existing Docker containers to a Blockade group
"""
config = load_config(opts.config)
b = get_blockade(config, opts)
b.add_container(opts.containers) |
def cmd_events(opts):
"""Get the event log for a given blockade
"""
config = load_config(opts.config)
b = get_blockade(config, opts)
if opts.json:
outf = None
_write = puts
if opts.output is not None:
outf = open(opts.output, "w")
_write = outf.write
... |
def set_cors_headers(resp, options):
"""
Performs the actual evaluation of Flas-CORS options and actually
modifies the response object.
This function is used both in the decorator and the after_request
callback
"""
# If CORS has already been evaluated via the decorator, skip
if hasattr... |
def try_match(request_origin, maybe_regex):
"""Safely attempts to match a pattern or string to a request origin."""
if isinstance(maybe_regex, RegexObject):
return re.match(maybe_regex, request_origin)
elif probably_regex(maybe_regex):
return re.match(maybe_regex, request_origin, flags=re.IG... |
def get_cors_options(appInstance, *dicts):
"""
Compute CORS options for an application by combining the DEFAULT_OPTIONS,
the app's configuration-specified options and any dictionaries passed. The
last specified option wins.
"""
options = DEFAULT_OPTIONS.copy()
options.update(get_app_kwarg_di... |
def get_app_kwarg_dict(appInstance=None):
"""Returns the dictionary of CORS specific app configurations."""
app = (appInstance or current_app)
# In order to support blueprints which do not have a config attribute
app_config = getattr(app, 'config', {})
return {
k.lower().replace('cors_', '... |
def ensure_iterable(inst):
"""
Wraps scalars or string types as a list, or returns the iterable instance.
"""
if isinstance(inst, string_types):
return [inst]
elif not isinstance(inst, collections.Iterable):
return [inst]
else:
return inst |
def serialize_options(opts):
"""
A helper method to serialize and processes the options dictionary.
"""
options = (opts or {}).copy()
for key in opts.keys():
if key not in DEFAULT_OPTIONS:
LOG.warning("Unknown option passed to Flask-CORS: %s", key)
# Ensure origins is a li... |
def cross_origin(*args, **kwargs):
"""
This function is the decorator which is used to wrap a Flask route with.
In the simplest case, simply use the default parameters to allow all
origins in what is the most permissive configuration. If this method
modifies state or performs authentication which ma... |
def calendar(type='holiday', direction='next', last=1, startDate=None, token='', version=''):
'''This call allows you to fetch a number of trade dates or holidays from a given date. For example, if you want the next trading day, you would call /ref-data/us/dates/trade/next/1.
https://iexcloud.io/docs/api/#u-s-... |
def calendarDF(type='holiday', direction='next', last=1, startDate=None, token='', version=''):
'''This call allows you to fetch a number of trade dates or holidays from a given date. For example, if you want the next trading day, you would call /ref-data/us/dates/trade/next/1.
https://iexcloud.io/docs/api/#u-... |
def holidays(direction='next', last=1, startDate=None, token='', version=''):
'''This call allows you to fetch a number of trade dates or holidays from a given date. For example, if you want the next trading day, you would call /ref-data/us/dates/trade/next/1.
https://iexcloud.io/docs/api/#u-s-exchanges
8a... |
def holidaysDF(direction='next', last=1, startDate=None, token='', version=''):
'''This call allows you to fetch a number of trade dates or holidays from a given date. For example, if you want the next trading day, you would call /ref-data/us/dates/trade/next/1.
https://iexcloud.io/docs/api/#u-s-exchanges
... |
def internationalSymbols(region='', exchange='', token='', version=''):
'''This call returns an array of international symbols that IEX Cloud supports for API calls.
https://iexcloud.io/docs/api/#international-symbols
8am, 9am, 12pm, 1pm UTC daily
Args:
region (string); region, 2 letter case i... |
def symbolsDF(token='', version=''):
'''This call returns an array of symbols that IEX Cloud supports for API calls.
https://iexcloud.io/docs/api/#symbols
8am, 9am, 12pm, 1pm UTC daily
Args:
token (string); Access token
version (string); API version
Returns:
dataframe: res... |
def iexSymbolsDF(token='', version=''):
'''This call returns an array of symbols the Investors Exchange supports for trading.
This list is updated daily as of 7:45 a.m. ET. Symbols may be added or removed by the Investors Exchange after the list was produced.
https://iexcloud.io/docs/api/#iex-symbols
8... |
def mutualFundSymbolsDF(token='', version=''):
'''This call returns an array of mutual fund symbols that IEX Cloud supports for API calls.
https://iexcloud.io/docs/api/#mutual-fund-symbols
8am, 9am, 12pm, 1pm UTC daily
Args:
token (string); Access token
version (string); API version
... |
def otcSymbolsDF(token='', version=''):
'''This call returns an array of OTC symbols that IEX Cloud supports for API calls.
https://iexcloud.io/docs/api/#otc-symbols
8am, 9am, 12pm, 1pm UTC daily
Args:
token (string); Access token
version (string); API version
Returns:
Dat... |
def internationalSymbolsDF(region='', exchange='', token='', version=''):
'''This call returns an array of international symbols that IEX Cloud supports for API calls.
https://iexcloud.io/docs/api/#international-symbols
8am, 9am, 12pm, 1pm UTC daily
Args:
region (string); region, 2 letter case... |
def internationalSymbolsList(region='', exchange='', token='', version=''):
'''This call returns an array of international symbols that IEX Cloud supports for API calls.
https://iexcloud.io/docs/api/#international-symbols
8am, 9am, 12pm, 1pm UTC daily
Args:
region (string); region, 2 letter ca... |
def marketsDF(token='', version=''):
'''https://iextrading.com/developer/docs/#intraday'''
df = pd.DataFrame(markets(token, version))
_toDatetime(df)
return df |
def _getJson(url, token='', version=''):
'''for backwards compat, accepting token and version but ignoring'''
if token:
return _getJsonIEXCloud(url, token, version)
return _getJsonOrig(url) |
def _getJsonOrig(url):
'''internal'''
url = _URL_PREFIX + url
resp = requests.get(urlparse(url).geturl(), proxies=_PYEX_PROXIES)
if resp.status_code == 200:
return resp.json()
raise PyEXception('Response %d - ' % resp.status_code, resp.text) |
def _getJsonIEXCloud(url, token='', version='beta'):
'''for iex cloud'''
url = _URL_PREFIX2.format(version=version) + url
resp = requests.get(urlparse(url).geturl(), proxies=_PYEX_PROXIES, params={'token': token})
if resp.status_code == 200:
return resp.json()
raise PyEXception('Response %d ... |
def _strOrDate(st):
'''internal'''
if isinstance(st, string_types):
return st
elif isinstance(st, datetime):
return st.strftime('%Y%m%d')
raise PyEXception('Not a date: %s', str(st)) |
def _raiseIfNotStr(s):
'''internal'''
if s is not None and not isinstance(s, string_types):
raise PyEXception('Cannot use type %s' % str(type(s))) |
def _tryJson(data, raw=True):
'''internal'''
if raw:
return data
try:
return json.loads(data)
except ValueError:
return data |
def _stream(url, sendinit=None, on_data=print):
'''internal'''
cl = WSClient(url, sendinit=sendinit, on_data=on_data)
return cl |
def _streamSSE(url, on_data=print, accrue=False):
'''internal'''
messages = SSEClient(url)
if accrue:
ret = []
for msg in messages:
data = msg.data
on_data(json.loads(data))
if accrue:
ret.append(msg)
return ret |
def _reindex(df, col):
'''internal'''
if col in df.columns:
df.set_index(col, inplace=True) |
def _toDatetime(df, cols=None, tcols=None):
'''internal'''
cols = cols or _STANDARD_DATE_FIELDS
tcols = tcols = _STANDARD_TIME_FIELDS
for col in cols:
if col in df:
df[col] = pd.to_datetime(df[col], infer_datetime_format=True, errors='coerce')
for tcol in tcols:
if tcol... |
def balanceSheet(symbol, token='', version=''):
'''Pulls balance sheet data. Available quarterly (4 quarters) and annually (4 years)
https://iexcloud.io/docs/api/#balance-sheet
Updates at 8am, 9am UTC daily
Args:
symbol (string); Ticker to request
token (string); Access token
... |
def balanceSheetDF(symbol, token='', version=''):
'''Pulls balance sheet data. Available quarterly (4 quarters) and annually (4 years)
https://iexcloud.io/docs/api/#balance-sheet
Updates at 8am, 9am UTC daily
Args:
symbol (string); Ticker to request
token (string); Access token
... |
def batch(symbols, fields=None, range_='1m', last=10, token='', version=''):
'''Batch several data requests into one invocation
https://iexcloud.io/docs/api/#batch-requests
Args:
symbols (list); List of tickers to request
fields (list); List of fields to request
range_ (string); D... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.