Instruction:
Write a Python 3 function for
connecting this task to the indicating outgoing task with the details in aptcha the sequence flow.

Response:
def connect_outgoing(self, outgoing_task, outgoing_task_node,
                         sequence_flow_node, is_default):
        """
        Connects this task to the indicating outgoing task, with the details in
        the sequence flow. A subclass can override this method to get extra
        information from the node.
        """
        self.task.connect_outgoing(
            outgoing_task, sequence_flow_node.get('id'),
            sequence_flow_node.get(
                'name', None),
            self.parser._parse_documentation(sequence_flow_node,
                                             task_parser=self))


Instruction:
Make a summary of the following Python 3 code
def connect_outgoing(self, taskspec, sequence_flow_id, sequence_flow_name,
                         documentation):
        """
        Connect this task spec to the indicated child.

        :param sequence_flow_id: The ID of the connecting sequenceFlow node.

        :param sequence_flow_name: The name of the connecting sequenceFlow
        node.
        """
        self.connect(taskspec)
        s = SequenceFlow(
            sequence_flow_id, sequence_flow_name, documentation, taskspec)
        self.outgoing_sequence_flows[taskspec.name] = s
        self.outgoing_sequence_flows_by_id[sequence_flow_id] = s

Response: Connect this taskspec to the indicated child.


Instruction:
Write a Python 3 script to
connect this taskspec to the indicated child if the condition evaluates to true.

Response:
def connect_outgoing_if(self, condition, taskspec, sequence_flow_id,
                            sequence_flow_name, documentation):
        """
        Connect this task spec to the indicated child, if the condition
        evaluates to true. This should only be called if the task has a
        connect_if method (e.g. ExclusiveGateway).

        :param sequence_flow_id: The ID of the connecting sequenceFlow node.

        :param sequence_flow_name: The name of the connecting sequenceFlow
        node.
        """
        self.connect_if(_BpmnCondition(condition), taskspec)
        s = SequenceFlow(
            sequence_flow_id, sequence_flow_name, documentation, taskspec)
        self.outgoing_sequence_flows[taskspec.name] = s
        self.outgoing_sequence_flows_by_id[sequence_flow_id] = s


Instruction:
Make a summary of the following Python 3 code
def get_outgoing_sequence_names(self):
        return sorted([s.name for s in
                       list(self.outgoing_sequence_flows_by_id.values())])

Response: Returns a list of the names of outgoing sequences. Some may be None.


Instruction:
How would you code a function in Python 3 to
connect a taskspec that is executed if the condition DOES match.

Response:
def connect_if(self, condition, task_spec):
        """
        Connects a taskspec that is executed if the condition DOES match.

        condition -- a condition (Condition)
        taskspec -- the conditional task spec
        """
        assert task_spec is not None
        self.outputs.append(task_spec)
        self.cond_task_specs.append((condition, task_spec.name))
        task_spec._connect_notify(self)


Instruction:
Can you generate the documentation for the following Python 3 function
def _on_complete_hook(self, my_task):
        # Find all matching conditions.
        outputs = []
        for condition, output in self.cond_task_specs:
            if self.choice is not None and output not in self.choice:
                continue
            if condition is None:
                outputs.append(self._wf_spec.get_task_spec_from_name(output))
                continue
            if not condition._matches(my_task):
                continue
            outputs.append(self._wf_spec.get_task_spec_from_name(output))

        my_task._sync_children(outputs, Task.FUTURE)
        for child in my_task.children:
            child.task_spec._update(child)

Response: Called by the task when the task is complete.


Instruction:
How would you explain what the following Python 3 function does
def is_completed(self):
        mask = Task.NOT_FINISHED_MASK
        iter = Task.Iterator(self.task_tree, mask)
        try:
            next(iter)
        except StopIteration:
            # No waiting tasks found.
            return True
        return False

Response: Returns True if the entire workflow is completed False otherwise.


Instruction:
Create a Python 3 function for
canceling all open tasks in the workflow.

Response:
def cancel(self, success=False):
        """
        Cancels all open tasks in the workflow.

        :type  success: bool
        :param success: Whether the Workflow should be marked as successfully
                        completed.
        """
        self.success = success
        cancel = []
        mask = Task.NOT_FINISHED_MASK
        for task in Task.Iterator(self.task_tree, mask):
            cancel.append(task)
        for task in cancel:
            task.cancel()


Instruction:
Create a Python 3 function to
return the task with the given id.

Response:
def get_task(self, id):
        """
        Returns the task with the given id.

        :type id:integer
        :param id: The id of a task.
        :rtype: Task
        :returns: The task with the given id.
        """
        tasks = [task for task in self.get_tasks() if task.id == id]
        return tasks[0] if len(tasks) == 1 else None


Instruction:
Write a Python 3 script to
return all tasks that relate to the given spec with the given name.

Response:
def get_tasks_from_spec_name(self, name):
        """
        Returns all tasks whose spec has the given name.

        :type name: str
        :param name: The name of a task spec.
        :rtype: Task
        :return: The task that relates to the spec with the given name.
        """
        return [task for task in self.get_tasks()
                if task.task_spec.name == name]


Instruction:
Can you tell what is the following Python 3 function doing
def get_tasks(self, state=Task.ANY_MASK):
        return [t for t in Task.Iterator(self.task_tree, state)]

Response: Returns a list of Task objects with the given state.


Instruction:
Given the following Python 3 function, write the documentation
def complete_task_from_id(self, task_id):
        if task_id is None:
            raise WorkflowException(self.spec, 'task_id is None')
        for task in self.task_tree:
            if task.id == task_id:
                return task.complete()
        msg = 'A task with the given task_id (%s) was not found' % task_id
        raise WorkflowException(self.spec, msg)

Response: Runs the task with the given id.


Instruction:
Can you generate the documentation for the following Python 3 function
def complete_next(self, pick_up=True, halt_on_manual=True):
        # Try to pick up where we left off.
        blacklist = []
        if pick_up and self.last_task is not None:
            try:
                iter = Task.Iterator(self.last_task, Task.READY)
                task = next(iter)
            except StopIteration:
                task = None
            self.last_task = None
            if task is not None:
                if not (halt_on_manual and task.task_spec.manual):
                    if task.complete():
                        self.last_task = task
                        return True
                blacklist.append(task)

        # Walk through all ready tasks.
        for task in Task.Iterator(self.task_tree, Task.READY):
            for blacklisted_task in blacklist:
                if task._is_descendant_of(blacklisted_task):
                    continue
            if not (halt_on_manual and task.task_spec.manual):
                if task.complete():
                    self.last_task = task
                    return True
            blacklist.append(task)

        # Walk through all waiting tasks.
        for task in Task.Iterator(self.task_tree, Task.WAITING):
            task.task_spec._update(task)
            if not task._has_state(Task.WAITING):
                self.last_task = task
                return True
        return False

Response: Runs the next task.


Instruction:
Create a Python 3 function for
running all branches until completion.

Response:
def complete_all(self, pick_up=True, halt_on_manual=True):
        """
        Runs all branches until completion. This is a convenience wrapper
        around :meth:`complete_next`, and the pick_up argument is passed
        along.

        :type  pick_up: bool
        :param pick_up: Passed on to each call of complete_next().
        :type  halt_on_manual: bool
        :param halt_on_manual: When True, this method will not attempt to
                        complete any tasks that have manual=True.
                        See :meth:`SpiffWorkflow.specs.TaskSpec.__init__`
        """
        while self.complete_next(pick_up, halt_on_manual):
            pass


Instruction:
Here you have a function in Python 3, explain what it does
def ref(function, callback=None):
    try:
        function.__func__
    except AttributeError:
        return _WeakMethodFree(function, callback)
    return _WeakMethodBound(function, callback)

Response: Returns a weak reference to the given method or function.


Instruction:
Given the following Python 3 function, write the documentation
def serialize_workflow(self, workflow, include_spec=False, **kwargs):
        if include_spec:
            raise NotImplementedError(
                'Including the spec serialization with the workflow state '
                'is not implemented.')
        return self._get_workflow_state(workflow)

Response: Serialize a workflow instance into a CompactWorkflowSerializer object.


Instruction:
Create a Python 3 function to
create a new BPMN workflow instance from the given spec and arguments.

Response:
def new_workflow(self, workflow_spec, read_only=False, **kwargs):
        """
        Create a new workflow instance from the given spec and arguments.

        :param workflow_spec: the workflow spec to use

        :param read_only: this should be in read only mode

        :param kwargs: Any extra kwargs passed to the deserialize_workflow
        method will be passed through here
        """
        return BpmnWorkflow(workflow_spec, read_only=read_only, **kwargs)


Instruction:
Write a Python 3 function that can
start the process and returns True when successfully fired False otherwise

Response:
def _start(self, my_task, force=False):
        """Returns False when successfully fired, True otherwise"""
        if (not hasattr(my_task, 'subprocess')) or my_task.subprocess is None:
            my_task.subprocess = subprocess.Popen(self.args,
                                                  stderr=subprocess.STDOUT,
                                                  stdout=subprocess.PIPE)

        if my_task.subprocess:
            my_task.subprocess.poll()
            if my_task.subprocess.returncode is None:
                # Still waiting
                return False
            else:
                results = my_task.subprocess.communicate()
                my_task.results = results
                return True
        return False


Instruction:
Write a Python 3 script to
set the state of the current object to the given value.

Response:
def _setstate(self, value, force=False):
        """
        Setting force to True allows for changing a state after it
        COMPLETED. This would otherwise be invalid.
        """
        if self._state == value:
            return
        if value < self._state and not force:
            raise WorkflowException(self.task_spec,
                                    'state went from %s to %s!' % (
                                        self.get_state_name(),
                                        self.state_names[value]))
        if __debug__:
            old = self.get_state_name()
        self._state = value
        if __debug__:
            self.log.append("Moving '%s' from %s to %s" % (
                self.get_name(),
                old, self.get_state_name()))
        self.state_history.append(value)
        LOG.debug("Moving '%s' (spec=%s) from %s to %s" % (
            self.get_name(),
            self.task_spec.name, old, self.get_state_name()))


Instruction:
Explain what the following Python 3 code does
def _set_state(self, state, force=True):
        self._setstate(state, True)
        self.last_state_change = time.time()

Response: Sets the state of the current object to state.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def _add_child(self, task_spec, state=MAYBE):
        if task_spec is None:
            raise ValueError(self, '_add_child() requires a TaskSpec')
        if self._is_predicted() and state & self.PREDICTED_MASK == 0:
            msg = 'Attempt to add non-predicted child to predicted task'
            raise WorkflowException(self.task_spec, msg)
        task = Task(self.workflow, task_spec, self, state=state)
        task.thread_id = self.thread_id
        if state == self.READY:
            task._ready()
        return task

Response: Adds a new child task and assigns the given TaskSpec to it.


Instruction:
How would you explain what the following Python 3 function does
def _assign_new_thread_id(self, recursive=True):
        self.__class__.thread_id_pool += 1
        self.thread_id = self.__class__.thread_id_pool
        if not recursive:
            return self.thread_id
        for child in self:
            child.thread_id = self.thread_id
        return self.thread_id

Response: Assigns a new thread id to the task.


Instruction:
Here you have a function in Python 3, explain what it does
def _is_descendant_of(self, parent):
        if self.parent is None:
            return False
        if self.parent == parent:
            return True
        return self.parent._is_descendant_of(parent)

Response: Returns True if self. parent is a descendant of parent.


Instruction:
Can you implement a function in Python 3 that
returns the child of the given parent task.

Response:
def _find_child_of(self, parent_task_spec):
        """
        Returns the ancestor that has a task with the given task spec
        as a parent.
        If no such ancestor was found, the root task is returned.

        :type  parent_task_spec: TaskSpec
        :param parent_task_spec: The wanted ancestor.
        :rtype:  Task
        :returns: The child of the given ancestor.
        """
        if self.parent is None:
            return self
        if self.parent.task_spec == parent_task_spec:
            return self
        return self.parent._find_child_of(parent_task_spec)


Instruction:
Can you generate the documentation for the following Python 3 function
def _find_any(self, task_spec):
        tasks = []
        if self.task_spec == task_spec:
            tasks.append(self)
        for child in self:
            if child.task_spec != task_spec:
                continue
            tasks.append(child)
        return tasks

Response: Returns any descendants that have the given task spec assigned.


Instruction:
Can you write a function in Python 3 where it
returns the ancestor that has the given task spec assigned.

Response:
def _find_ancestor(self, task_spec):
        """
        Returns the ancestor that has the given task spec assigned.
        If no such ancestor was found, the root task is returned.

        :type  task_spec: TaskSpec
        :param task_spec: The wanted task spec.
        :rtype:  Task
        :returns: The ancestor.
        """
        if self.parent is None:
            return self
        if self.parent.task_spec == task_spec:
            return self.parent
        return self.parent._find_ancestor(task_spec)


Instruction:
Here you have a function in Python 3, explain what it does
def _find_ancestor_from_name(self, name):
        if self.parent is None:
            return None
        if self.parent.get_name() == name:
            return self.parent
        return self.parent._find_ancestor_from_name(name)

Response: Returns the ancestor that has a task with the given name assigned.


Instruction:
Here you have a function in Python 3, explain what it does
def _ready(self):
        if self._has_state(self.COMPLETED) or self._has_state(self.CANCELLED):
            return
        self._set_state(self.READY)
        self.task_spec._on_ready(self)

Response: Mark the task as ready for execution.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def get_state_name(self):
        state_name = []
        for state, name in list(self.state_names.items()):
            if self._has_state(state):
                state_name.append(name)
        return '|'.join(state_name)

Response: Returns a textual representation of this Task s state.


Instruction:
Given the following Python 3 function, write the documentation
def _inherit_data(self):
        LOG.debug("'%s' inheriting data from '%s'" % (self.get_name(),
                                                      self.parent.get_name()),
                  extra=dict(data=self.parent.data))
        self.set_data(**self.parent.data)

Response: Inherits the data from the parent.


Instruction:
Write a Python 3 script for
canceling the item if it was not yet completed.

Response:
def cancel(self):
        """
        Cancels the item if it was not yet completed, and removes
        any children that are LIKELY.
        """
        if self._is_finished():
            for child in self.children:
                child.cancel()
            return
        self._set_state(self.CANCELLED)
        self._drop_children()
        self.task_spec._on_cancel(self)


Instruction:
Can you implement a function in Python 3 that
calls by the task to let us know that the task is complete.

Response:
def complete(self):
        """
        Called by the associated task to let us know that its state
        has changed (e.g. from FUTURE to COMPLETED.)
        """
        self._set_state(self.COMPLETED)
        return self.task_spec._on_complete(self)


Instruction:
Can you write a function in Python 3 where it
returns the debug information of the current object.

Response:
def get_dump(self, indent=0, recursive=True):
        """
        Returns the subtree as a string for debugging.

        :rtype:  str
        :returns: The debug information.
        """
        dbg = (' ' * indent * 2)
        dbg += '%s/' % self.id
        dbg += '%s:' % self.thread_id
        dbg += ' Task of %s' % self.get_name()
        if self.task_spec.description:
            dbg += ' (%s)' % self.get_description()
        dbg += ' State: %s' % self.get_state_name()
        dbg += ' Children: %s' % len(self.children)
        if recursive:
            for child in self.children:
                dbg += '\n' + child.get_dump(indent + 1)
        return dbg


Instruction:
Write a Python 3 function for
parsing args and evaluates any Attrib entries

Response:
def _eval_args(args, my_task):
    """Parses args and evaluates any Attrib entries"""
    results = []
    for arg in args:
        if isinstance(arg, Attrib) or isinstance(arg, PathAttrib):
            results.append(valueof(my_task, arg))
        else:
            results.append(arg)
    return results


Instruction:
Write a Python 3 script for
parsing kwargs and evaluates any Attrib entries

Response:
def _eval_kwargs(kwargs, my_task):
    """Parses kwargs and evaluates any Attrib entries"""
    results = {}
    for kwarg, value in list(kwargs.items()):
        if isinstance(value, Attrib) or isinstance(value, PathAttrib):
            results[kwarg] = valueof(my_task, value)
        else:
            results[kwarg] = value
    return results


Instruction:
Write a Python 3 function that can
make sure an object is JSON - serializable

Response:
def Serializable(o):
    """Make sure an object is JSON-serializable
    Use this to return errors and other info that does not need to be
    deserialized or does not contain important app data. Best for returning
    error info and such"""
    if isinstance(o, (str, dict, int)):
        return o
    else:
        try:
            json.dumps(o)
            return o
        except Exception:
            LOG.debug("Got a non-serilizeable object: %s" % o)
            return o.__repr__()


Instruction:
Implement a Python 3 function for
sending a Celery asynchronous call and stores the async call information for the laster

Response:
def _send_call(self, my_task):
        """Sends Celery asynchronous call and stores async call information for
        retrieval laster"""
        args, kwargs = None, None
        if self.args:
            args = _eval_args(self.args, my_task)
        if self.kwargs:
            kwargs = _eval_kwargs(self.kwargs, my_task)
        LOG.debug(
            "%s (task id %s) calling %s" % (self.name, my_task.id, self.call),
            extra=dict(data=dict(args=args, kwargs=kwargs)))
        async_call = default_app.send_task(self.call, args=args, kwargs=kwargs)
        my_task._set_internal_data(task_id=async_call.task_id)
        my_task.async_call = async_call
        LOG.debug("'%s' called: %s" % (self.call, my_task.async_call.task_id))


Instruction:
Explain what the following Python 3 code does
def _restart(self, my_task):
        if not my_task._has_state(Task.WAITING):
            raise WorkflowException(my_task, "Cannot refire a task that is not"
                                    "in WAITING state")
        # Check state of existing call and abort it (save history)
        if my_task._get_internal_data('task_id') is not None:
            if not hasattr(my_task, 'async_call'):
                task_id = my_task._get_internal_data('task_id')
                my_task.async_call = default_app.AsyncResult(task_id)
                my_task.deserialized = True
                my_task.async_call.state  # manually refresh
            async_call = my_task.async_call
            if async_call.state == 'FAILED':
                pass
            elif async_call.state in ['RETRY', 'PENDING', 'STARTED']:
                async_call.revoke()
                LOG.info("Celery task '%s' was in %s state and was revoked" % (
                    async_call.state, async_call))
            elif async_call.state == 'SUCCESS':
                LOG.warning("Celery task '%s' succeeded, but a refire was "
                            "requested" % async_call)
            self._clear_celery_task_data(my_task)
        # Retrigger
        return self._start(my_task)

Response: Restart a celery task.


Instruction:
Create a Python 3 function for
clearing celery task data.

Response:
def _clear_celery_task_data(self, my_task):
        """ Clear celery task data """
        # Save history
        if 'task_id' in my_task.internal_data:
            # Save history for diagnostics/forensics
            history = my_task._get_internal_data('task_history', [])
            history.append(my_task._get_internal_data('task_id'))
            del my_task.internal_data['task_id']
            my_task._set_internal_data(task_history=history)
        if 'task_state' in my_task.internal_data:
            del my_task.internal_data['task_state']
        if 'error' in my_task.internal_data:
            del my_task.internal_data['error']
        if hasattr(my_task, 'async_call'):
            delattr(my_task, 'async_call')
        if hasattr(my_task, 'deserialized'):
            delattr(my_task, 'deserialized')


Instruction:
Can you generate the documentation for the following Python 3 function
def _start(self, my_task, force=False):

        # Deserialize async call if necessary
        if not hasattr(my_task, 'async_call') and \
                my_task._get_internal_data('task_id') is not None:
            task_id = my_task._get_internal_data('task_id')
            my_task.async_call = default_app.AsyncResult(task_id)
            my_task.deserialized = True
            LOG.debug("Reanimate AsyncCall %s" % task_id)

        # Make the call if not already done
        if not hasattr(my_task, 'async_call'):
            self._send_call(my_task)

        # Get call status (and manually refresh if deserialized)
        if getattr(my_task, "deserialized", False):
            my_task.async_call.state  # must manually refresh if deserialized
        if my_task.async_call.state == 'FAILURE':
            LOG.debug("Async Call for task '%s' failed: %s" % (
                my_task.get_name(), my_task.async_call.info))
            info = {}
            info['traceback'] = my_task.async_call.traceback
            info['info'] = Serializable(my_task.async_call.info)
            info['state'] = my_task.async_call.state
            my_task._set_internal_data(task_state=info)
        elif my_task.async_call.state == 'RETRY':
            info = {}
            info['traceback'] = my_task.async_call.traceback
            info['info'] = Serializable(my_task.async_call.info)
            info['state'] = my_task.async_call.state
            my_task._set_internal_data(task_state=info)
        elif my_task.async_call.ready():
            result = my_task.async_call.result
            if isinstance(result, Exception):
                LOG.warn("Celery call %s failed: %s" % (self.call, result))
                my_task._set_internal_data(error=Serializable(result))
                return False
            LOG.debug("Completed celery call %s with result=%s" % (self.call,
                                                                   result))
            # Format result
            if self.result_key:
                data = {self.result_key: result}
            else:
                if isinstance(result, dict):
                    data = result
                else:
                    data = {'result': result}
            # Load formatted result into internal_data
            if self.merge_results:
                merge_dictionary(my_task.internal_data, data)
            else:
                my_task.set_data(**data)
            return True
        else:
            LOG.debug("async_call.ready()=%s. TryFire for '%s' "
                      "returning False" % (my_task.async_call.ready(),
                                           my_task.get_name()))
            return False

Response: Returns False when successfully fired True otherwise


Instruction:
Can you generate a brief explanation for the following Python 3 code
def ancestors(self):
        results = []

        def recursive_find_ancestors(task, stack):
            for input in task.inputs:
                if input not in stack:
                    stack.append(input)
                    recursive_find_ancestors(input, stack)
        recursive_find_ancestors(self, results)

        return results

Response: Returns a list of ancestor task specs based on inputs


Instruction:
Here you have a function in Python 3, explain what it does
def set_data(self, **kwargs):
        for key in kwargs:
            if key in self.defines:
                msg = "Spec data %s can not be modified" % key
                raise WorkflowException(self, msg)
        self.data.update(kwargs)

Response: Sets the data of the current object to the given values.


Instruction:
Write a Python 3 function that can
connect the following task to this one.

Response:
def connect(self, taskspec):
        """
        Connect the *following* task to this one. In other words, the
        given task is added as an output task.

        :type  taskspec: TaskSpec
        :param taskspec: The new output task.
        """
        self.outputs.append(taskspec)
        taskspec._connect_notify(self)


Instruction:
Implement a function in Python 3 to
update the branch such that all possible future routes are added. Should NOT be overwritten! Instead, overwrite _predict_hook(). :type my_task: Task :param my_task: The associated task in the task tree. :type seen: list[taskspec] :param seen: A list of already visited tasks. :type looked_ahead: integer :param looked_ahead: The depth of the predicted path so far.

Response:
def _predict(self, my_task, seen=None, looked_ahead=0):
        """
        Updates the branch such that all possible future routes are added.

        Should NOT be overwritten! Instead, overwrite _predict_hook().

        :type  my_task: Task
        :param my_task: The associated task in the task tree.
        :type  seen: list[taskspec]
        :param seen: A list of already visited tasks.
        :type  looked_ahead: integer
        :param looked_ahead: The depth of the predicted path so far.
        """
        if my_task._is_finished():
            return
        if seen is None:
            seen = []
        elif self in seen:
            return
        if not my_task._is_finished():
            self._predict_hook(my_task)
        if not my_task._is_definite():
            if looked_ahead + 1 >= self.lookahead:
                return
            seen.append(self)
        for child in my_task.children:
            child.task_spec._predict(child, seen[:], looked_ahead + 1)


Instruction:
Explain what the following Python 3 code does
def _update_hook(self, my_task):
        if my_task._is_predicted():
            self._predict(my_task)
        LOG.debug("'%s'._update_hook says parent (%s, state=%s) "
                  "is_finished=%s" % (self.name, my_task.parent.get_name(),
                                      my_task.parent.get_state_name(),
                                      my_task.parent._is_finished()))
        if not my_task.parent._is_finished():
            return
        self.entered_event.emit(my_task.workflow, my_task)
        my_task._ready()

Response: This method is called by the task manager when the task is finished.


Instruction:
Given the following Python 3 function, write the documentation
def _on_ready(self, my_task):
        assert my_task is not None
        self.test()

        # Acquire locks, if any.
        for lock in self.locks:
            mutex = my_task.workflow._get_mutex(lock)
            if not mutex.testandset():
                return

        # Assign variables, if so requested.
        for assignment in self.pre_assign:
            assignment.assign(my_task, my_task)

        # Run task-specific code.
        self._on_ready_before_hook(my_task)
        self.reached_event.emit(my_task.workflow, my_task)
        self._on_ready_hook(my_task)

        # Run user code, if any.
        if self.ready_event.emit(my_task.workflow, my_task):
            # Assign variables, if so requested.
            for assignment in self.post_assign:
                assignment.assign(my_task, my_task)

        # Release locks, if any.
        for lock in self.locks:
            mutex = my_task.workflow._get_mutex(lock)
            mutex.unlock()

        self.finished_event.emit(my_task.workflow, my_task)

Response: Called by the task manager when the task tree is ready.


Instruction:
Implement a Python 3 function for
calling by the TaskManager when the task is complete.

Response:
def _on_complete(self, my_task):
        """
        Return True on success, False otherwise. Should not be overwritten,
        overwrite _on_complete_hook() instead.

        :type  my_task: Task
        :param my_task: The associated task in the task tree.
        :rtype:  boolean
        :returns: True on success, False otherwise.
        """
        assert my_task is not None

        if my_task.workflow.debug:
            print("Executing %s: %s (%s)" % (
                my_task.task_spec.__class__.__name__,
                my_task.get_name(), my_task.get_description()))

        self._on_complete_hook(my_task)

        # Notify the Workflow.
        my_task.workflow._task_completed_notify(my_task)

        if my_task.workflow.debug:
            if hasattr(my_task.workflow, "outer_workflow"):
                my_task.workflow.outer_workflow.task_tree.dump()

        self.completed_event.emit(my_task.workflow, my_task)
        return True


Instruction:
Make a summary of the following Python 3 code
def create_package(self):

        # Check that all files exist (and calculate the longest shared path
        # prefix):
        self.input_path_prefix = None
        for filename in self.input_files:
            if not os.path.isfile(filename):
                raise ValueError(
                    '%s does not exist or is not a file' % filename)
            if self.input_path_prefix:
                full = os.path.abspath(os.path.dirname(filename))
                while not (full.startswith(self.input_path_prefix) and
                           self.input_path_prefix):
                    self.input_path_prefix = self.input_path_prefix[:-1]
            else:
                self.input_path_prefix = os.path.abspath(
                    os.path.dirname(filename))

        # Parse all of the XML:
        self.bpmn = {}
        for filename in self.input_files:
            bpmn = ET.parse(filename)
            self.bpmn[os.path.abspath(filename)] = bpmn

        # Now run through pre-parsing and validation:
        for filename, bpmn in list(self.bpmn.items()):
            bpmn = self.pre_parse_and_validate(bpmn, filename)
            self.bpmn[os.path.abspath(filename)] = bpmn

        # Now check that we can parse it fine:
        for filename, bpmn in list(self.bpmn.items()):
            self.parser.add_bpmn_xml(bpmn, filename=filename)

        self.wf_spec = self.parser.get_spec(self.entry_point_process)

        # Now package everything:
        self.package_zip = zipfile.ZipFile(
            self.package_file, "w", compression=zipfile.ZIP_DEFLATED)

        done_files = set()
        for spec in self.wf_spec.get_specs_depth_first():
            filename = spec.file
            if filename not in done_files:
                done_files.add(filename)

                bpmn = self.bpmn[os.path.abspath(filename)]
                self.write_to_package_zip(
                    "%s.bpmn" % spec.name, ET.tostring(bpmn.getroot()))

                self.write_file_to_package_zip(
                    "src/" + self._get_zip_path(filename), filename)

                self._call_editor_hook('package_for_editor', spec, filename)

        self.write_meta_data()
        self.write_manifest()

        self.package_zip.close()

Response: Creates the package for the current entry - point process.


Instruction:
Given the following Python 3 function, write the documentation
def write_file_to_package_zip(self, filename, src_filename):
        f = open(src_filename)
        with f:
            data = f.read()
        self.manifest[filename] = md5hash(data)
        self.package_zip.write(src_filename, filename)

Response: Writes a local file in to the zip file and adds it to the manifest


Instruction:
Implement a function in Python 3 to
write data to the zip file and adds it to the manifest dictionary

Response:
def write_to_package_zip(self, filename, data):
        """
        Writes data to the zip file and adds it to the manifest dictionary

        :param filename: The zip file name

        :param data: the data
        """
        self.manifest[filename] = md5hash(data)
        self.package_zip.writestr(filename, data)


Instruction:
Can you generate a brief explanation for the following Python 3 code
def write_manifest(self):
        config = configparser.ConfigParser()

        config.add_section('Manifest')

        for f in sorted(self.manifest.keys()):
            config.set('Manifest', f.replace(
                '\\', '/').lower(), self.manifest[f])

        ini = StringIO()
        config.write(ini)
        self.manifest_data = ini.getvalue()
        self.package_zip.writestr(self.MANIFEST_FILE, self.manifest_data)

Response: Write the manifest content to the package zip file.


Instruction:
How would you explain what the following Python 3 function does
def pre_parse_and_validate_signavio(self, bpmn, filename):
        self._check_for_disconnected_boundary_events_signavio(bpmn, filename)
        self._fix_call_activities_signavio(bpmn, filename)
        return bpmn

Response: This method is called before parsing and validating signavio content.


Instruction:
Create a Python 3 function to
package the signavio file for this BPMN file.

Response:
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/" + self._get_zip_path(signavio_file), signavio_file)

            f = open(signavio_file, 'r')
            try:
                signavio_tree = ET.parse(f)
            finally:
                f.close()
            svg_node = one(signavio_tree.findall('.//svg-representation'))
            self.write_to_package_zip("%s.svg" % spec.name, svg_node.text)


Instruction:
Here you have a function in Python 3, explain what it does
def write_meta_data(self):
        config = configparser.ConfigParser()

        config.add_section('MetaData')
        config.set('MetaData', 'entry_point_process', self.wf_spec.name)
        if self.editor:
            config.set('MetaData', 'editor', self.editor)

        for k, v in self.meta_data:
            config.set('MetaData', k, v)

        if not self.PARSER_CLASS == BpmnParser:
            config.set('MetaData', 'parser_class_module',
                       inspect.getmodule(self.PARSER_CLASS).__name__)
            config.set('MetaData', 'parser_class', self.PARSER_CLASS.__name__)

        ini = StringIO()
        config.write(ini)
        self.write_to_package_zip(self.METADATA_FILE, ini.getvalue())

Response: Writes the metadata. ini file to the archive.


Instruction:
Implement a Python 3 function for
overriding in subclass if required.

Response:
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",
                          help="specify the entry point process")
        parser.add_option("-c", "--config-file", dest="config_file",
                          help="specify a config file to use")
        parser.add_option(
            "-i", "--initialise-config-file", action="store_true",
            dest="init_config_file", default=False,
            help="create a new config file from the specified options")

        group = OptionGroup(parser, "BPMN Editor Options",
                            "These options are not required, but may be "
                            " provided to activate special features of "
                            "supported BPMN editors.")
        group.add_option("--editor", dest="editor",
                         help="editors with special support: signavio")
        parser.add_option_group(group)


Instruction:
Implement a function in Python 3 to
override in subclass if required.

Response:
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 "
                            "BPMN application engine is targeted.")
        group.add_option("-e", "--target-engine", dest="target_engine",
                         help="target the specified BPMN application engine")
        group.add_option(
            "-t", "--target-version", dest="target_engine_version",
            help="target the specified version of the BPMN application engine")
        parser.add_option_group(group)


Instruction:
Make a summary of the following Python 3 code
def check_args(cls, config, options, args, parser, package_file=None):
        if not args:
            parser.error("no input files specified")
        if not (package_file or options.package_file):
            parser.error("no package file specified")
        if not options.entry_point_process:
            parser.error("no entry point process specified")

Response: Check if the arguments are valid.


Instruction:
How would you implement a function in Python 3 that
overrides in subclass if required.

Response:
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(CONFIG_SECTION_NAME, 'input_files').split(','):
                if not os.path.isabs(i):
                    i = os.path.abspath(
                        os.path.join(os.path.dirname(options.config_file), i))
                args.append(i)

        cls.merge_option_and_config_str('package_file', config, options)
        cls.merge_option_and_config_str('entry_point_process', config, options)
        cls.merge_option_and_config_str('target_engine', config, options)
        cls.merge_option_and_config_str(
            'target_engine_version', config, options)
        cls.merge_option_and_config_str('editor', config, options)


Instruction:
Write a Python 3 function that can
create meta data for the current version of the class.

Response:
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 options.target_engine:
            meta_data.append(
                ('target_engine_version', options.target_engine_version))
        return meta_data


Instruction:
How would you explain what the following Python 3 function does
def parse_node(self, node):

        if node.get('id') in self.parsed_nodes:
            return self.parsed_nodes[node.get('id')]

        (node_parser, spec_class) = self.parser._get_parser_class(node.tag)
        if not node_parser or not spec_class:
            raise ValidationException(
                "There is no support implemented for this task type.",
                node=node, filename=self.filename)
        np = node_parser(self, spec_class, node)
        task_spec = np.parse_node()

        return task_spec

Response: Parses the specified child task node and returns the task spec.


Instruction:
How would you explain what the following Python 3 function does
def get_spec(self):
        if self.is_parsed:
            return self.spec
        if self.parsing_started:
            raise NotImplementedError(
                'Recursive call Activities are not supported.')
        self._parse()
        return self.get_spec()

Response: Parse this process and return the workflow spec.


Instruction:
Can you write a function in Python 3 where it
calls when a task is triggered.

Response:
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 = Task.READY
        else:
            state = Task.FUTURE
        for output in self.outputs:
            new_task = my_task._add_child(output, state)
            new_task.triggered = True
            output._predict(new_task)


Instruction:
Implement a Python 3 function for
connecting the given task to this one.

Response:
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)


Instruction:
Given the following Python 3 function, write the documentation
def _get_activated_tasks(self, my_task, destination):
        task = destination._find_ancestor(self.thread_starter)
        return self.thread_starter._get_activated_tasks(task, destination)

Response:
Returns the list of tasks that were activated in the previous TaskSpec
        call of execute.


Instruction:
Can you tell what is the following Python 3 function doing
def _on_trigger(self, my_task):
        for output in self.outputs:
            new_task = my_task.add_child(output, Task.READY)
            new_task.triggered = True

Response: Called when the task is triggered.


Instruction:
Write a Python 3 script to
read the pre - assign or post - assign tag from the given workflow.

Response:
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 = start_node.getAttribute('value')
        kwargs = {}
        if name == '':
            _exc('name attribute required')
        if attrib != '' and value != '':
            _exc('Both, field and right-value attributes found')
        elif attrib == '' and value == '':
            _exc('field or value attribute required')
        elif value != '':
            kwargs['right'] = value
        else:
            kwargs['right_attribute'] = attrib
        return operators.Assign(name, **kwargs)


Instruction:
Can you write a function in Python 3 where it
reads a data or define tag from the given node.

Response:
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


Instruction:
Can you tell what is the following Python 3 function doing
def deserialize_assign_list(self, workflow, start_node):
        # Collect all information.
        assignments = []
        for node in start_node.childNodes:
            if node.nodeType != minidom.Node.ELEMENT_NODE:
                continue
            if node.nodeName.lower() == 'assign':
                assignments.append(self.deserialize_assign(workflow, node))
            else:
                _exc('Unknown node: %s' % node.nodeName)
        return assignments

Response: Reads a list of assignments from the given node.


Instruction:
Create a Python 3 function to
read the logical tag from the given node returns a Condition object.

Response:
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.nodeName.lower()
        term2_attrib = node.getAttribute('right-field')
        term2_value = node.getAttribute('right-value')
        if op not in _op_map:
            _exc('Invalid operator')
        if term1_attrib != '' and term1_value != '':
            _exc('Both, left-field and left-value attributes found')
        elif term1_attrib == '' and term1_value == '':
            _exc('left-field or left-value attribute required')
        elif term1_value != '':
            left = term1_value
        else:
            left = operators.Attrib(term1_attrib)
        if term2_attrib != '' and term2_value != '':
            _exc('Both, right-field and right-value attributes found')
        elif term2_attrib == '' and term2_value == '':
            _exc('right-field or right-value attribute required')
        elif term2_value != '':
            right = term2_value
        else:
            right = operators.Attrib(term2_attrib)
        return _op_map[op](left, right)


Instruction:
How would you explain what the following Python 3 function does
def deserialize_condition(self, workflow, start_node):
        # Collect all information.
        condition = None
        spec_name = None
        for node in start_node.childNodes:
            if node.nodeType != minidom.Node.ELEMENT_NODE:
                continue
            if node.nodeName.lower() == 'successor':
                if spec_name is not None:
                    _exc('Duplicate task name %s' % spec_name)
                if node.firstChild is None:
                    _exc('Successor tag without a task name')
                spec_name = node.firstChild.nodeValue
            elif node.nodeName.lower() in _op_map:
                if condition is not None:
                    _exc('Multiple conditions are not yet supported')
                condition = self.deserialize_logical(node)
            else:
                _exc('Unknown node: %s' % node.nodeName)

        if condition is None:
            _exc('Missing condition in conditional statement')
        if spec_name is None:
            _exc('A %s has no task specified' % start_node.nodeName)
        return condition, spec_name

Response: Reads the condition from the given workflow and returns it.


Instruction:
How would you explain what the following Python 3 function does
def deserialize_task_spec(self, workflow, start_node, read_specs):
        # Extract attributes from the node.
        nodetype = start_node.nodeName.lower()
        name = start_node.getAttribute('name').lower()
        context = start_node.getAttribute('context').lower()
        mutex = start_node.getAttribute('mutex').lower()
        cancel = start_node.getAttribute('cancel').lower()
        success = start_node.getAttribute('success').lower()
        times = start_node.getAttribute('times').lower()
        times_field = start_node.getAttribute('times-field').lower()
        threshold = start_node.getAttribute('threshold').lower()
        threshold_field = start_node.getAttribute('threshold-field').lower()
        file = start_node.getAttribute('file').lower()
        file_field = start_node.getAttribute('file-field').lower()
        kwargs = {'lock':        [],
                  'data':        {},
                  'defines':     {},
                  'pre_assign':  [],
                  'post_assign': []}
        if nodetype not in _spec_map:
            _exc('Invalid task type "%s"' % nodetype)
        if nodetype == 'start-task':
            name = 'start'
        if name == '':
            _exc('Invalid task name "%s"' % name)
        if name in read_specs:
            _exc('Duplicate task name "%s"' % name)
        if cancel != '' and cancel != '0':
            kwargs['cancel'] = True
        if success != '' and success != '0':
            kwargs['success'] = True
        if times != '':
            kwargs['times'] = int(times)
        if times_field != '':
            kwargs['times'] = operators.Attrib(times_field)
        if threshold != '':
            kwargs['threshold'] = int(threshold)
        if threshold_field != '':
            kwargs['threshold'] = operators.Attrib(threshold_field)
        if file != '':
            kwargs['file'] = file
        if file_field != '':
            kwargs['file'] = operators.Attrib(file_field)
        if nodetype == 'choose':
            kwargs['choice'] = []
        if nodetype == 'trigger':
            context = [context]
        if mutex != '':
            context = mutex

        # Walk through the children of the node.
        successors = []
        for node in start_node.childNodes:
            if node.nodeType != minidom.Node.ELEMENT_NODE:
                continue
            if node.nodeName == 'description':
                kwargs['description'] = node.firstChild.nodeValue
            elif node.nodeName == 'successor' \
                    or node.nodeName == 'default-successor':
                if node.firstChild is None:
                    _exc('Empty %s tag' % node.nodeName)
                successors.append((None, node.firstChild.nodeValue))
            elif node.nodeName == 'conditional-successor':
                successors.append(self.deserialize_condition(workflow, node))
            elif node.nodeName == 'define':
                key, value = self.deserialize_data(workflow, node)
                kwargs['defines'][key] = value
            # "property" tag exists for backward compatibility.
            elif node.nodeName == 'data' or node.nodeName == 'property':
                key, value = self.deserialize_data(workflow, node)
                kwargs['data'][key] = value
            elif node.nodeName == 'pre-assign':
                kwargs['pre_assign'].append(
                    self.deserialize_assign(workflow, node))
            elif node.nodeName == 'post-assign':
                kwargs['post_assign'].append(
                    self.deserialize_assign(workflow, node))
            elif node.nodeName == 'in':
                kwargs['in_assign'] = self.deserialize_assign_list(
                    workflow, node)
            elif node.nodeName == 'out':
                kwargs['out_assign'] = self.deserialize_assign_list(
                    workflow, node)
            elif node.nodeName == 'cancel':
                if node.firstChild is None:
                    _exc('Empty %s tag' % node.nodeName)
                if context == '':
                    context = []
                elif not isinstance(context, list):
                    context = [context]
                context.append(node.firstChild.nodeValue)
            elif node.nodeName == 'lock':
                if node.firstChild is None:
                    _exc('Empty %s tag' % node.nodeName)
                kwargs['lock'].append(node.firstChild.nodeValue)
            elif node.nodeName == 'pick':
                if node.firstChild is None:
                    _exc('Empty %s tag' % node.nodeName)
                kwargs['choice'].append(node.firstChild.nodeValue)
            else:
                _exc('Unknown node: %s' % node.nodeName)

        # Create a new instance of the task spec.
        module = _spec_map[nodetype]
        if nodetype == 'start-task':
            spec = module(workflow, **kwargs)
        elif nodetype == 'multi-instance' or nodetype == 'thread-split':
            if times == '' and times_field == '':
                _exc('Missing "times" or "times-field" in "%s"' % name)
            elif times != '' and times_field != '':
                _exc('Both, "times" and "times-field" in "%s"' % name)
            spec = module(workflow, name, **kwargs)
        elif context == '':
            spec = module(workflow, name, **kwargs)
        else:
            spec = module(workflow, name, context, **kwargs)

        read_specs[name] = spec, successors

Response: Reads the task from the given node and returns a tuple containing the start and end timestamps of the task.


Instruction:
Given the following Python 3 function, write the documentation
def deserialize_workflow_spec(self, s_state, filename=None):
        dom = minidom.parseString(s_state)
        node = dom.getElementsByTagName('process-definition')[0]
        name = node.getAttribute('name')
        if name == '':
            _exc('%s without a name attribute' % node.nodeName)

        # Read all task specs and create a list of successors.
        workflow_spec = specs.WorkflowSpec(name, filename)
        del workflow_spec.task_specs['Start']
        end = specs.Simple(workflow_spec, 'End'), []
        read_specs = dict(end=end)
        for child_node in node.childNodes:
            if child_node.nodeType != minidom.Node.ELEMENT_NODE:
                continue
            if child_node.nodeName == 'name':
                workflow_spec.name = child_node.firstChild.nodeValue
            elif child_node.nodeName == 'description':
                workflow_spec.description = child_node.firstChild.nodeValue
            elif child_node.nodeName.lower() in _spec_map:
                self.deserialize_task_spec(
                    workflow_spec, child_node, read_specs)
            else:
                _exc('Unknown node: %s' % child_node.nodeName)

        # Remove the default start-task from the workflow.
        workflow_spec.start = read_specs['start'][0]

        # Connect all task specs.
        for name in read_specs:
            spec, successors = read_specs[name]
            for condition, successor_name in successors:
                if successor_name not in read_specs:
                    _exc('Unknown successor: "%s"' % successor_name)
                successor, foo = read_specs[successor_name]
                if condition is None:
                    spec.connect(successor)
                else:
                    spec.connect_if(condition, successor)
        return workflow_spec

Response: Reads the workflow from the given XML structure and returns a new WorkflowSpec instance.


Instruction:
Can you generate the documentation for the following Python 3 function
def has_fired(self, my_task):
        dt = my_task.workflow.script_engine.evaluate(my_task, self.dateTime)
        if dt is None:
            return False
        if dt.tzinfo:
            tz = dt.tzinfo
            now = tz.fromutc(datetime.datetime.utcnow().replace(tzinfo=tz))
        else:
            now = datetime.datetime.now()
        return now > dt

Response:
Returns True if the Timer has fired if the evaluated dateTime
 expression is before datetime. now


Instruction:
How would you code a function in Python 3 to
add a new task spec to the list of available task sources.

Response:
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 = len(self.task_specs)


Instruction:
Implement a Python 3 function for
checking integrity of the workflow and reports any problems with it.

Response:
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 recursive_find_loop(task, history):
            current = history[:]
            current.append(task)
            if isinstance(task, Join):
                if task in history:
                    msg = "Found loop with '%s': %s then '%s' again" % (
                        task.name, '->'.join([p.name for p in history]),
                        task.name)
                    raise Exception(msg)
                for predecessor in task.inputs:
                    recursive_find_loop(predecessor, current)

            for parent in task.inputs:
                recursive_find_loop(parent, current)

        for task_id, task in list(self.task_specs.items()):
            # Check for cyclic waits
            try:
                recursive_find_loop(task, [])
            except Exception as exc:
                results.append(exc.__str__())

            # Check for disconnected tasks
            if not task.inputs and task.name not in ['Start', 'Root']:
                if task.outputs:
                    results.append("Task '%s' is disconnected (no inputs)" %
                                   task.name)
                else:
                    LOG.debug("Task '%s' is not being used" % task.name)

        return results


Instruction:
Here you have a function in Python 3, explain what it does
def accept_message(self, message):
        assert not self.read_only
        self.refresh_waiting_tasks()
        self.do_engine_steps()
        for my_task in Task.Iterator(self.task_tree, Task.WAITING):
            my_task.task_spec.accept_message(my_task, message)

Response:
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.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def do_engine_steps(self):
        assert not self.read_only
        engine_steps = list(
            [t for t in self.get_tasks(Task.READY)
             if self._is_engine_task(t.task_spec)])
        while engine_steps:
            for task in engine_steps:
                task.complete()
            engine_steps = list(
                [t for t in self.get_tasks(Task.READY)
                 if self._is_engine_task(t.task_spec)])

Response: Execute any READY tasks that are engine specific.


Instruction:
Write a Python 3 script to
refresh the state of all WAITING tasks.

Response:
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._update(my_task)


Instruction:
Given the following Python 3 function, write the documentation
def get_ready_user_tasks(self):
        return [t for t in self.get_tasks(Task.READY)
                if not self._is_engine_task(t.task_spec)]

Response: Returns a list of User Tasks that are READY for user action


Instruction:
Implement a Python 3 function for
calling when a task is triggered.

Response:
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.workflow.task_tree:
            if thetask.thread_id != my_task.thread_id:
                continue
            if (thetask.task_spec == self and
                    thetask._has_state(Task.COMPLETED)):
                thetask._set_state(Task.FUTURE, True)
                thetask._ready()


Instruction:
How would you implement a function in Python 3 that
evaluates the given expression within the context of the given task and return the result.

Response:
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, **task.data)


Instruction:
Can you tell what is the following Python 3 function doing
def execute(self, task, script, **kwargs):
        locals().update(kwargs)
        exec(script)

Response: Execute the script within the context of the task


Instruction:
Write a Python 3 function for
checking whether the threshold is reached and if so starts the task.

Response:
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 reached, there is nothing else to do.
        if my_task._has_state(Task.COMPLETED):
            return True, None
        if my_task._has_state(Task.READY):
            return True, None

        # Check whether we may fire.
        if self.split_task is None:
            return self._check_threshold_unstructured(my_task, force)
        return self._check_threshold_structured(my_task, force)


Instruction:
Can you generate the documentation for the following Python 3 function
def _on_trigger(self, my_task):
        for task in my_task.workflow.task_tree._find_any(self):
            if task.thread_id != my_task.thread_id:
                continue
            self._do_join(task)

Response: Called when the Task is triggered.


Instruction:
Write a Python 3 function that can
connect the task spec that is executed if no other condition matches.

Response:
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)
        self.default_task_spec = task_spec.name
        task_spec._connect_notify(self)


Instruction:
Can you tell what is the following Python 3 function doing
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

Response: Try to find the container ID with the specified name


Instruction:
Can you tell what is the following Python 3 function doing
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)

Response: Initialize a new state file with the given contents.


Instruction:
Can you implement a function in Python 3 that
updates the current state file with the specified contents

Response:
def update(self, containers):
        '''Update the current state file with the specified contents'''
        self._containers = deepcopy(containers)
        self.__write(containers, initialize=False)


Instruction:
How would you explain what the following Python 3 function does
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.ENOENT:
                raise NotInitializedError("No blockade exists in this context")
            raise InconsistentStateError("Failed to load Blockade state: "
                                         + str(err))
        except Exception as err:
            raise InconsistentStateError("Failed to load Blockade state: "
                                         + str(err))

Response: Try to load a blockade state file in the current directory and store it in the internal object


Instruction:
Can you create a Python 3 function that
generates a new blockade ID based on the CWD

Response:
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()
        blockade_id = re.sub(r"[^a-z0-9]", "", basename)
        if not blockade_id:  # if we can't get a valid name from CWD, use "default"
            blockade_id = "default"
        return blockade_id


Instruction:
Implement a function in Python 3 to
make sure the state directory exists

Response:
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


Instruction:
Given the following Python 3 function, write the documentation
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)
        except OSError as err:
            if err.errno not in (errno.ENOTEMPTY, errno.ENOENT):
                raise

Response: Try to delete the state. yml file and the folder. blockade


Instruction:
Create a Python 3 function for
converting blockade ID and container information into a state dictionary object.

Response:
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)


Instruction:
How would you implement a function in Python 3 that
writes the given state information into a file.

Response:
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.open(path, flags), "w") as f:
                yaml.safe_dump(self.__base_state(containers), f)
        except OSError as err:
            if err.errno == errno.EEXIST:
                raise AlreadyInitializedError(
                    "Path %s exists. "
                    "You may need to destroy a previous blockade." % path)
            raise
        except Exception:
            # clean up our created file
            self._state_delete()
            raise


Instruction:
Create a Python 3 function for
validating the partitions of containers.

Response:
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 containers if not c.holy)
    holy_names = frozenset(c.name for c in containers if c.holy)
    neutral_names = frozenset(c.name for c in containers if c.neutral)
    partitions = [frozenset(p) for p in partitions]

    unknown = set()
    holy = set()
    union = set()

    for partition in partitions:
        unknown.update(partition - all_names - holy_names)
        holy.update(partition - all_names)
        union.update(partition)

    if unknown:
        raise BlockadeError('Partitions contain unknown containers: %s' %
                            list(unknown))

    if holy:
        raise BlockadeError('Partitions contain holy containers: %s' %
                            list(holy))

    # put any leftover containers in an implicit partition
    leftover = all_names.difference(union)
    if leftover:
        partitions.append(leftover)

    # we create an 'implicit' partition for the neutral containers
    # in case they are not part of the leftover anyways
    if not neutral_names.issubset(leftover):
        partitions.append(neutral_names)

    return partitions


Instruction:
Can you generate a brief explanation for the following Python 3 code
def get_source_chains(self, blockade_id):
        result = {}
        if not blockade_id:
            raise ValueError("invalid blockade_id")
        lines = self.get_chain_rules("FORWARD")

        for line in lines:
            parts = line.split()
            if len(parts) < 4:
                continue
            try:
                partition_index = parse_partition_index(blockade_id, parts[0])
            except ValueError:
                continue  # not a rule targetting a blockade chain

            source = parts[3]
            if source:
                result[source] = partition_index
        return result

Response: Get a map of blockade chains IDs -> list of IPs targeted at them


Instruction:
Write a Python 3 function for
inserting a new rule in the chain.

Response:
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 src, dest, or both")

        args = ["-I", chain]
        if src:
            args += ["-s", src]
        if dest:
            args += ["-d", dest]
        args += ["-j", target]
        self.call(*args)


Instruction:
Create a Python 3 function for
starting the timer waiting for pain

Response:
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()


Instruction:
Implement a function in Python 3 to
start the blockade event and start the pain event

Response:
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_time)
        self._timer = threading.Timer(millisec / 1000.0, self.event_timeout)
        self._timer.start()


Instruction:
Can you implement a function in Python 3 that
stops chaos when there is no current blockade operation

Response:
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)
        self._timer.cancel()


Instruction:
Can you write a function in Python 3 where it
ends the blockade event and return to a steady state

Response:
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
        millisec = random.randint(self._start_min_delay, self._start_max_delay)
        self._timer = threading.Timer(millisec/1000.0, self.event_timeout)
        self._timer.start()


Instruction:
Can you implement a function in Python 3 that
deletes all state associated with the chaos session

Response:
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()


Instruction:
How would you implement a function in Python 3 that
sorts a dictionary or list of containers into dependency order Returns a list of containers

Response:
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()))
                           for name, c in containers.items())
    sorted_names = _resolve(container_links)
    return [containers[name] for name in sorted_names]


Instruction:
Explain what the following Python 3 code does
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_value, int):
            count = max(count_value, 1)

        def with_index(name, idx):
            if name and idx:
                return '%s_%d' % (name, idx)
            return name

        def get_instance(n, idx=None):
            return BlockadeContainerConfig(
                with_index(n, idx),
                values['image'],
                command=values.get('command'),
                links=values.get('links'),
                volumes=values.get('volumes'),
                publish_ports=values.get('ports'),
                expose_ports=values.get('expose'),
                environment=values.get('environment'),
                hostname=values.get('hostname'),
                dns=values.get('dns'),
                start_delay=values.get('start_delay', 0),
                neutral=values.get('neutral', False),
                holy=values.get('holy', False),
                container_name=with_index(values.get('container_name'), idx),
                cap_add=values.get('cap_add'))

        if count == 1:
            yield get_instance(name)
        else:
            for idx in range(1, count+1):
                # TODO: configurable name/index format
                yield get_instance(name, idx)

Response:
Convert a dictionary of configuration values
        into a sequence of BlockadeContainerConfig instances.


Instruction:
Write a Python 3 script to
start the containers and link them together

Response:
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)


Instruction:
Can you generate a brief explanation for the following Python 3 code
def cmd_destroy(opts):
    config = load_config(opts.config)
    b = get_blockade(config, opts)
    b.destroy()

Response: Destroy all containers and restore networks


Instruction:
How would you explain what the following Python 3 function does
def cmd_status(opts):
    config = load_config(opts.config)
    b = get_blockade(config, opts)
    containers = b.status()
    print_containers(containers, opts.json)

Response: Print status of containers and networks


Instruction:
Write a Python 3 function for
killing some or all containers

Response:
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)


Instruction:
Write a Python 3 script for
partitioning the network between containers and opts. partitions

Response:
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 c1

    The result will be a partition with just c1 and another partition with
    c2 and c3.

    Alternatively, --random may be specified, and zero or more random
    partitions will be generated by blockade.
    """
    config = load_config(opts.config)
    b = get_blockade(config, opts)

    if opts.random:
        if opts.partitions:
            raise BlockadeError("Either specify individual partitions "
                                "or --random, but not both")
        b.random_partition()

    else:
        partitions = []
        for partition in opts.partitions:
            names = []
            for name in partition.split(","):
                name = name.strip()
                if name:
                    names.append(name)
            partitions.append(names)
        if not partitions:
            raise BlockadeError("Either specify individual partitions "
                                "or random")
        b.partition(partitions)


Instruction:
Can you write a function in Python 3 where it
restores full networking between containers

Response:
def cmd_join(opts):
    """Restore full networking between containers
    """
    config = load_config(opts.config)
    b = get_blockade(config, opts)
    b.join()


Instruction:
Can you generate a brief explanation for the following Python 3 code
def cmd_logs(opts):
    config = load_config(opts.config)
    b = get_blockade(config, opts)
    puts(b.logs(opts.container).decode(encoding='UTF-8'))

Response: Fetch the logs of a container


Instruction:
How would you explain what the following Python 3 function does
def cmd_daemon(opts):
    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())

Response: Start the Blockade REST API


Instruction:
Explain what the following Python 3 code does
def cmd_add(opts):
    config = load_config(opts.config)
    b = get_blockade(config, opts)
    b.add_container(opts.containers)

Response: Add one or more Docker containers to a Blockade group


Instruction:
How would you explain what the following Python 3 function does
def cmd_events(opts):
    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
        try:
            delim = ""
            logs = b.get_audit().read_logs(as_json=False)
            _write('{"events": [')
            _write(os.linesep)
            for l in logs:
                _write(delim + l)
                delim = "," + os.linesep
            _write(os.linesep)
            _write(']}')
        finally:
            if opts.output is not None:
                outf.close()
    else:
        puts(colored.blue(columns(["EVENT",         10],
                                  ["TARGET",        16],
                                  ["STATUS",         8],
                                  ["TIME",          16],
                                  ["MESSAGE",       25])))

        logs = b.get_audit().read_logs(as_json=True)
        for l in logs:
            puts(columns([l['event'],                          10],
                         [str([str(t) for t in l['targets']]), 16],
                         [l['status'],                          8],
                         [str(l['timestamp']),                 16],
                         [l['message'],                        25]))

Response: Get the event log for a given blockade


Instruction:
Make a summary of the following Python 3 code
def set_cors_headers(resp, options):

    # If CORS has already been evaluated via the decorator, skip
    if hasattr(resp, FLASK_CORS_EVALUATED):
        LOG.debug('CORS have been already evaluated, skipping')
        return resp

    # Some libraries, like OAuthlib, set resp.headers to non Multidict
    # objects (Werkzeug Headers work as well). This is a problem because
    # headers allow repeated values.
    if (not isinstance(resp.headers, Headers)
           and not isinstance(resp.headers, MultiDict)):
        resp.headers = MultiDict(resp.headers)

    headers_to_set = get_cors_headers(options, request.headers, request.method)

    LOG.debug('Settings CORS headers: %s', str(headers_to_set))

    for k, v in headers_to_set.items():
        resp.headers.add(k, v)

    return resp

Response: Sets the CORS headers for the response object.


Instruction:
Can you tell what is the following Python 3 function doing
def try_match(request_origin, maybe_regex):
    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.IGNORECASE)
    else:
        try:
            return request_origin.lower() == maybe_regex.lower()
        except AttributeError:
            return request_origin == maybe_regex

Response: Safely attempts to match a pattern or string to a request origin.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def get_cors_options(appInstance, *dicts):
    options = DEFAULT_OPTIONS.copy()
    options.update(get_app_kwarg_dict(appInstance))
    if dicts:
        for d in dicts:
            options.update(d)

    return serialize_options(options)

Response: Compute the CORS options for an application by combining the DEFAULT_OPTIONS and any dictionaries passed in.


Instruction:
Make a summary of the following Python 3 code
def get_app_kwarg_dict(appInstance=None):
    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_', ''): app_config.get(k)
        for k in CONFIG_OPTIONS
        if app_config.get(k) is not None
    }

Response: Returns the dictionary of CORS specific app configurations.


Instruction:
Write a Python 3 script to
ensure that an instance is iterable.

Response:
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


Instruction:
Can you generate a brief explanation for the following Python 3 code
def serialize_options(opts):
    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 list of allowed origins with at least one entry.
    options['origins'] = sanitize_regex_param(options.get('origins'))
    options['allow_headers'] = sanitize_regex_param(options.get('allow_headers'))

    # This is expressly forbidden by the spec. Raise a value error so people
    # don't get burned in production.
    if r'.*' in options['origins'] and options['supports_credentials'] and options['send_wildcard']:
        raise ValueError("Cannot use supports_credentials in conjunction with"
                         "an origin string of '*'. See: "
                         "http://www.w3.org/TR/cors/#resource-requests")

    serialize_option(options, 'expose_headers')
    serialize_option(options, 'methods', upper=True)

    if isinstance(options.get('max_age'), timedelta):
        options['max_age'] = str(int(options['max_age'].total_seconds()))

    return options

Response: Serialize the options dictionary to a dictionary of options.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def cross_origin(*args, **kwargs):
    _options = kwargs

    def decorator(f):
        LOG.debug("Enabling %s for cross_origin using options:%s", f, _options)

        # If True, intercept OPTIONS requests by modifying the view function,
        # replicating Flask's default behavior, and wrapping the response with
        # CORS headers.
        #
        # If f.provide_automatic_options is unset or True, Flask's route
        # decorator (which is actually wraps the function object we return)
        # intercepts OPTIONS handling, and requests will not have CORS headers
        if _options.get('automatic_options', True):
            f.required_methods = getattr(f, 'required_methods', set())
            f.required_methods.add('OPTIONS')
            f.provide_automatic_options = False

        def wrapped_function(*args, **kwargs):
            # Handle setting of Flask-Cors parameters
            options = get_cors_options(current_app, _options)

            if options.get('automatic_options') and request.method == 'OPTIONS':
                resp = current_app.make_default_options_response()
            else:
                resp = make_response(f(*args, **kwargs))

            set_cors_headers(resp, options)
            setattr(resp, FLASK_CORS_EVALUATED, True)
            return resp

        return update_wrapper(wrapped_function, f)
    return decorator

Response: This decorator is used to add cross - origin parameters to the cross - origin route.


Instruction:
Can you tell what is the following Python 3 function doing
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-exchanges
    8am, 9am, 12pm, 1pm UTC daily

    Args:
        type (string); "holiday" or "trade"
        direction (string); "next" or "last"
        last (int); number to move in direction
        startDate (date); start date for next or last, YYYYMMDD
        token (string); Access token
        version (string); API version

    Returns:
        dict: result
    '''
    if startDate:
        startDate = _strOrDate(startDate)
        return _getJson('ref-data/us/dates/{type}/{direction}/{last}/{date}'.format(type=type, direction=direction, last=last, date=startDate), token, version)
    return _getJson('ref-data/us/dates/' + type + '/' + direction + '/' + str(last), token, version)

Response: This function returns a number of trade dates or holidays from a given date.


Instruction:
Given the following Python 3 function, write the documentation
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-s-exchanges
    8am, 9am, 12pm, 1pm UTC daily

    Args:
        type (string); "holiday" or "trade"
        direction (string); "next" or "last"
        last (int); number to move in direction
        startDate (date); start date for next or last, YYYYMMDD
        token (string); Access token
        version (string); API version

    Returns:
        dict: result
    '''
    dat = pd.DataFrame(calendar(type, direction, last, startDate, token, version))
    _toDatetime(dat)
    return dat

Response: This function allows you to fetch a number of trade dates or holidays from a given date.


Instruction:
How would you explain what the following Python 3 function does
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 insensitive string of country codes using ISO 3166-1 alpha-2
        exchange (string): Case insensitive string of Exchange using IEX Supported Exchanges list
        token (string); Access token
        version (string); API version

    Returns:
        dict: result
    '''
    if region:
        return _getJson('ref-data/region/{region}/symbols'.format(region=region), token, version)
    elif exchange:
        return _getJson('ref-data/exchange/{exchange}/exchange'.format(exchange=exchange), token, version)
    return _getJson('ref-data/region/us/symbols', token, version)

Response: This function returns an array of international symbols that IEX Cloud supports for API calls.


Instruction:
Explain what the following Python 3 code does
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: result
    '''
    df = pd.DataFrame(symbols(token, version))
    _toDatetime(df)
    _reindex(df, 'symbol')
    return df

Response: This function returns a dataframe that contains the current IEX Cloud symbols for the given token and version.


Instruction:
Given the following Python 3 function, write the documentation
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
    8am, 9am, 12pm, 1pm UTC daily

    Args:
        token (string); Access token
        version (string); API version

    Returns:
        DataFrame: result
    '''
    df = pd.DataFrame(iexSymbols(token, version))
    _toDatetime(df)
    _reindex(df, 'symbol')
    return df

Response: This function returns a DataFrame containing the list of symbols that the Investors Exchange supports for trading.


Instruction:
Make a summary of the following Python 3 code
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 case insensitive string of country codes using ISO 3166-1 alpha-2
        exchange (string): Case insensitive string of Exchange using IEX Supported Exchanges list
        token (string); Access token
        version (string); API version

    Returns:
        list: result
    '''
    return internationalSymbolsDF(region, exchange, token, version).index.tolist()

Response: This function returns an array of international symbols that IEX Cloud supports for API calls. It returns an array of international symbols that IEX Cloud supports for API calls.


Instruction:
Can you write a function in Python 3 where it
returns a pandas DataFrame with the markets for the given token and version.

Response:
def marketsDF(token='', version=''):
    '''https://iextrading.com/developer/docs/#intraday'''
    df = pd.DataFrame(markets(token, version))
    _toDatetime(df)
    return df


Instruction:
Can you tell what is the following Python 3 function doing
def _getJson(url, token='', version=''):
    '''for backwards compat, accepting token and version but ignoring'''
    if token:
        return _getJsonIEXCloud(url, token, version)
    return _getJsonOrig(url)

Response: for backwards compat with accepting token and version but ignoring


Instruction:
Here you have a function in Python 3, explain what it does
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)

Response: Internal method to get the JSON content of a resource.


Instruction:
Make a summary of the following Python 3 code
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 - ' % resp.status_code, resp.text)

Response: Get the json for iex cloud


Instruction:
Write a Python 3 function for
raising an exception if s is not a string.

Response:
def _raiseIfNotStr(s):
    '''internal'''
    if s is not None and not isinstance(s, string_types):
        raise PyEXception('Cannot use type %s' % str(type(s)))


Instruction:
Here you have a function in Python 3, explain what it does
def _tryJson(data, raw=True):
    '''internal'''
    if raw:
        return data
    try:
        return json.loads(data)
    except ValueError:
        return data

Response: Internal function to try json data.


Instruction:
Can you tell what is the following Python 3 function doing
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

Response: Stream the contents of an SSE message from a URL.


Instruction:
Given the following Python 3 function, write the documentation
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 in df:
            df[tcol] = pd.to_datetime(df[tcol], unit='ms', errors='coerce')

Response: Internal function to convert a dataframe to a datetime.


Instruction:
Given the following Python 3 function, write the documentation
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
        version (string); API version

    Returns:
        dict: result
    '''
    _raiseIfNotStr(symbol)
    return _getJson('stock/' + symbol + '/balance-sheet', token, version)

Response: Pulls balance sheet data. Available quarterly and annually ( 4 years ) and annually ( 4 years ).


Instruction:
Create a Python 3 function to
pull balance sheet data. Available quarterly and annually ( 4 years ) and annually ( 4 years )

Response:
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
        version (string); API version

    Returns:
        DataFrame: result
    '''
    val = balanceSheet(symbol, token, version)
    df = pd.io.json.json_normalize(val, 'balancesheet', 'symbol')
    _toDatetime(df)
    _reindex(df, 'reportDate')
    return df