uuPythonlab 0.2.4__py3-none-any.whl

pythonlab/__init__.py

@@ -0,0 +1,5 @@
+"""Top-level package for pythonLab."""
+
+__author__ = """mark doerr"""
+__email__ = "mark.doerr@uni-greifswald.de"
+__version__ = "0.2.4"

pythonlab/process.py

@@ -0,0 +1,141 @@
+"""_____________________________________________________________________
+
+:PROJECT: pythonLab
+
+*process base class*
+
+:details:
+
+:authors: mark doerr (mark@uni-greifswald.de)
+          Stefan Maak
+
+:date: (creation)          20210410
+
+________________________________________________________________________
+
+"""
+
+import logging
+from enum import Enum
+from typing import List
+
+from abc import ABC, abstractmethod
+
+# should be done through plugin system
+from pythonlab.resource import ServiceResource, LabwareResource
+
+
+class ExecutionConstraint(Enum):
+    immediate = 1
+    parallel = 2
+
+
+class PLProcess(ABC):
+    def __init__(self, priority=10):
+        self._priority = priority  # 0 has the highest priority
+        self._service_resources = []
+        self._labware_resources = []
+        self._substance_resources = []
+        self._data_resources = []
+        # indicates that the samples have to started in the same order,as they are added
+        self.preserve_order = False
+
+        self.labware_nodes = {}  # dict labware_name --> labware_start_node
+
+        self._service_resources = []
+        self.create_resources()
+        self.init_service_resources()
+
+    @abstractmethod
+    def create_resources(self):
+        raise NotImplementedError
+
+    @abstractmethod
+    def init_service_resources(self):
+        """calling all init routines.
+        If no additional code is required,
+        this can be called, using
+        super().init_resources() in an overwriting method.
+        """
+        for resource in self._service_resources:
+            resource.init()
+
+    def set_starting_position(
+        self, resource: LabwareResource, device: ServiceResource, position: int
+    ):
+        """
+        This method gets called when setting the starting position of a labware resource. It exists to be overwritten.
+        :param resource:
+        :param device:
+        :param position:
+        :return:
+        """
+
+    def add_process_step_priorities(self):
+        """we add waiting costs to all jobs, so these will be prioritised by scheduler
+        should be also add waiting costs before the start, so they will be started first?
+
+        :raises NotImplementedError: _description_
+        """
+
+    @abstractmethod
+    def process(self):
+        raise NotImplementedError
+
+    def add_process_step(
+        self,
+        service: ServiceResource,
+        labware: List[LabwareResource],
+        is_movement: bool = False,
+        **kwargs,
+    ):
+        """
+        This Method will be overwritten when the process is parsed. It is designed for service resources to add
+        process steps to the workflow.
+        :param service:
+        :param labware:
+        :param is_movement:
+        :param kwargs:
+        :return:
+        """
+        # todo: extend description since this is key to parsing and implementation on new service resources
+
+    def register_service_resource(self, resource):
+        logging.debug(f"reg service. res: {resource.name}")
+        self._service_resources.append(resource)
+
+    def register_labware_resource(self, resource):
+        logging.debug(f"reg labware res: {resource.name}")
+        self._labware_resources.append(resource)
+
+    def register_substance_resource(self, resource):
+        logging.debug(f"reg subst res: {resource.name}")
+        self._substance_resources.append(resource)
+
+    def register_data_resource(self, resource):
+        logging.debug(f"reg data res: {resource.name}")
+        self._data_resources.append(resource)
+
+    def shutdown_resources(self):
+        for resource in self._service_resources:
+            resource.shutdown()
+
+    @property
+    def service_resources(self):
+        return self._service_resources
+
+    @property
+    def labware_resources(self):
+        return self._labware_resources
+
+    @property
+    def substance_resources(self):
+        return self._substance_resources
+
+    @property
+    def data_resources(self):
+        return self._data_resources
+
+    @property
+    def priority(self):
+        return self._priority

pythonlab/pythonlab_reader.py

@@ -0,0 +1,500 @@
+"""
+Module with all necessary utility to parse a PythonLab process into a networkx graph.
+todo: use pydentic to parse it into defined dataclasses
+"""
+
+from __future__ import annotations
+
+import traceback
+import logging
+from abc import ABC
+import graphviz
+import inspect
+import ast
+from uuid import uuid1
+from pathlib import Path
+import sys
+from importlib.util import spec_from_file_location, module_from_spec
+import types
+import networkx as nx
+from pythonlab.process import PLProcess
+from pythonlab.resource import ServiceResource, DynamicLabwareResource, LabwareResource
+from typing import List, Dict, Any, Type
+from copy import deepcopy
+from contextlib import contextmanager
+
+
+@contextmanager
+def get_source_code(src: str, node: ast.AST) -> str:
+    try:
+        code = ast.get_source_segment(src, node)
+        yield code
+    except Exception as ex:
+        logging.error(f"Caught Exception {ex} while parsing \n\n{code}\n")
+        raise ex
+
+
+def find_pl_process_class(module: types.ModuleType) -> type[PLProcess]:
+    process_classes = [
+        obj
+        for obj in module.__dict__.values()
+        if (
+            inspect.isclass(obj)
+            and issubclass(obj, PLProcess)
+            and obj is not PLProcess
+            and obj.__module__
+            == module.__name__  # ensure defined in this file, not imported
+        )
+    ]
+    if not process_classes:
+        raise RuntimeError(f"No subclass of PLProcess found in module {module.__name__}")
+    return process_classes[0]
+
+
+class PLProcessReader:
+    @staticmethod
+    def parse_process_from_file_path(file_path: str | Path):
+        spec = spec_from_file_location("importing_process", file_path)
+        sys.path.append(Path(file_path).parent.as_posix())
+        module = module_from_spec(spec)
+        sys.modules[spec.name] = module
+        spec.loader.exec_module(module)
+
+        # find the class implementing PLProcess
+        process_class = find_pl_process_class(module)
+        process = process_class()
+
+        # call the parsing from instance method
+        return PLProcessReader.parse_process_from_instance(process)
+
+    @staticmethod
+    def parse_process_from_source_code(src: str):
+        module_name = "tmp_module"
+        module = types.ModuleType(module_name)
+        # Execute the source code in the module's namespace.
+        exec(src, module.__dict__)
+
+        # Now, create an instance of the class implementing PLProcess.
+        process_class = find_pl_process_class(module)
+        process = process_class()
+
+        # retrieve all imports and add them to scope
+        scope = {}
+        tree = ast.parse(src)
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    stmt = f"import {alias.name}" + (f" as {alias.asname}" if alias.asname else "")
+                    exec(stmt, scope)
+            elif isinstance(node, ast.ImportFrom):
+                imports = ", ".join(
+                    f"{alias.name}" + (f" as {alias.asname}" if alias.asname else "")
+                    for alias in node.names
+                )
+                stmt = f"from {node.module} import {imports}"
+                exec(stmt, scope)
+        return PLProcessReader.parse_process(process, src, scope)
+
+    @staticmethod
+    def parse_process_from_instance(plp: PLProcess):
+        src = inspect.getsource(type(plp))
+        scope = {}
+        module_name = plp.__class__.__module__
+        module = sys.modules.get(module_name)
+        if module:
+            scope.update(module.__dict__)
+        return PLProcessReader.parse_process(plp, src, scope)
+
+    @staticmethod
+    def parse_process(plp: PLProcess, src=None, scope: dict | None = None):
+        """
+        The main function. It takes a PythonLabProcess and derives a SMProcess from it. The Information is stored
+        in Job and LabwareInfo classes from the structures-module.
+        """
+        if scope is None:
+            scope = {}
+        if src is None:
+            src = inspect.getsource(type(plp))
+        p = PLProcessReader.ast_get_process(type(plp), src)
+
+        class Simulator(PLProcessSimulator, type(plp)):
+            """This class is necessary to have the simulator inherit the methods of plp dynamically"""
+            def __init__(self):
+                PLProcessSimulator.__init__(self, type(plp))
+        simulator = Simulator()
+        scope.update({'self': simulator, '_break_nodes': []})
+        devices = [key for key, var in vars(simulator).items() if isinstance(var, ServiceResource)]
+        PLProcessReader.execute_scope(p.body, scope, [], src, devices, simulator)
+        # contract the dummy_nodes used to link the if-conditions and break-nodes correctly
+        PLProcessReader.contract_dummys(simulator.workflow)
+        return simulator
+
+    @staticmethod
+    def ast_get_process(process_type, src=None):
+        if src is None:
+            src = inspect.getsource(process_type)
+        module = ast.parse(src)
+        cl = [cls for cls in module.body if isinstance(cls, ast.ClassDef)][0]
+        fcts = [elem for elem in cl.body if isinstance(elem, ast.FunctionDef)]
+        processes = [elem for elem in fcts if elem.name == 'process']
+        return processes[0]
+
+    @staticmethod
+    def contract_dummys(g: nx.DiGraph):
+        """
+        This function contracts the dummy nodes in the workflow graph. To keep track of which labware participated in
+        which process step throughout exploring if-clauses, break commands, etc. the reader includes dummy nodes
+        into the workflow graph. In this function (after the whole process was read) these dummies are removed by
+        contraction, i.e., remove them and connect all sources of incoming edges to all targets of outgoing edges.
+        """
+        dummys = [n for n, data in g.nodes(data=True) if data['type'] == 'dummy']
+        for dummy in dummys:
+            # buff1 and buff1 are the same as dummy
+            for prior, buff1, data_in in g.in_edges(dummy, data=True):
+                for buff2, posterior, data_out in g.out_edges(dummy, data=True):
+                    label = f"{data_in['label']} {data_out['label']}"
+                    kwargs = data_in.copy()
+                    kwargs.update(data_out)
+                    kwargs['label'] = label
+                    g.add_edge(prior, posterior, **kwargs)
+            g.remove_node(dummy)
+
+    @staticmethod
+    def execute_scope(body: List[ast.AST], scope: Dict[str, Any], runtime_vars: List[str], src: str,
+                      devices: List[str], plp: PLProcessSimulator):
+        """
+        Goes through the list of code lines and constructs the workflow graph by manipulation the process state and
+        executing certain lines of process description code. Ment to be called recursively
+        :param plp:
+        :param devices: List of variables that correspond to ServiceResources
+        :param src: source code of the process description
+        :param body: list of parsed code fragments
+        :param scope: variables assigned so var
+        :param runtime_vars: list of variable names in current scope that are evaluated at runtime
+        :return: Nothing
+        """
+        # make shallow copies of scope and runtime_vars
+        scope = scope.copy()
+        for node in body:
+            if isinstance(node, ast.Expr):
+                PLProcessReader.handle_expr(node, scope, runtime_vars, src)
+            if isinstance(node, ast.Assign):
+                PLProcessReader.handle_assign(node, scope, runtime_vars, src, devices, plp)
+            if isinstance(node, ast.If):
+                try:
+                    PLProcessReader.handle_if(node, scope, runtime_vars, src, devices, plp)
+                except Exception as ex:
+                    logging.error(ex, traceback.print_exc())
+            if isinstance(node, ast.For):
+                PLProcessReader.handle_for(node, scope, runtime_vars, src, devices, plp)
+            if isinstance(node, ast.Break):
+                PLProcessReader.handle_break(scope, plp)
+
+    @staticmethod
+    def handle_expr(expr: ast.Expr, scope: Dict[str, Any], runtime_vars: List[str], src: str):
+        with get_source_code(src, expr) as code:
+            exec(code, scope)
+
+    @staticmethod
+    def handle_assign(asg: ast.Assign, scope: Dict[str, Any], runtime_vars: List[str], src: str, devices: List[str],
+                      plp: PLProcessSimulator):
+        with get_source_code(src, asg) as code:
+            is_runtime_var = any(f"attr='{d}'" in ast.dump(asg.value) for d in devices)
+            is_computation = any(f"id='{v}'" in ast.dump(asg.value) for v in runtime_vars)
+            var_names = [t.id for t in asg.targets if isinstance(t, ast.Name)]
+            if is_runtime_var:
+                exec(ast.get_source_segment(src, asg.value), scope)
+                plp.add_var_nodes(*var_names)
+                runtime_vars.extend([v for v in var_names if v not in runtime_vars])
+            elif is_computation:
+                used_vars = filter(lambda v: f"id='{v}'" in ast.dump(asg.value), runtime_vars)
+                needed = {key: val for key, val in scope.items() if key in code}
+                plp.add_computation(name=asg.targets[0].id, var_names=used_vars,
+                                    fct_code=ast.get_source_segment(src, asg.value), needed_scope=needed.copy())
+                runtime_vars.extend([v for v in var_names if v not in runtime_vars])
+            else:
+                exec(ast.get_source_segment(src, asg), scope)
+                for name in var_names:
+                    if name in runtime_vars:
+                        runtime_vars.remove(name)
+
+    @staticmethod
+    def handle_if(node: ast.If, scope: Dict[str, Any], runtime_vars: List[str], src: str, devices: List[str],
+                  plp: PLProcessSimulator):
+        is_runtime_decision = any(f"id='{v}'" in ast.dump(node.test) for v in runtime_vars)
+        if is_runtime_decision:
+            used_vars = filter(lambda v: f"id='{v}'" in ast.dump(node.test), runtime_vars)
+            with get_source_code(src, node.test) as code:
+                needed = {key: val for key, val in scope.items() if key in code}
+                if_node = plp.add_if_node(used_vars, code, needed)
+                origin_state = plp.get_state()
+                plp.prepare_true_execution(if_node)
+                PLProcessReader.execute_scope(node.body, scope, runtime_vars, src, devices, plp)
+                after_true_state = plp.get_state()
+                plp.prepare_false_execution(if_node)
+                PLProcessReader.execute_scope(node.orelse, scope, runtime_vars, src, devices, plp)
+                plp.join_state(after_true_state)
+                if len(scope['_break_nodes']) > 0:
+                    last_break = scope['_break_nodes'][0]
+                else:
+                    last_break = -1
+                plp.finalize_if_construction(if_node, origin_state, last_break=last_break)
+        else:
+            # if this is no runtime decision, we evaluate it and execute accordingly
+            with get_source_code(src, node.test) as code:
+                decision = eval(code, scope)
+                if decision:
+                    PLProcessReader.execute_scope(node.body, scope, runtime_vars, src, devices, plp)
+                else:
+                    PLProcessReader.execute_scope(node.orelse, scope, runtime_vars, src, devices, plp)
+
+    @staticmethod
+    def handle_for(node: ast.For, scope: Dict[str, Any], runtime_vars: List[str], src: str, devices: List[str],
+                   plp: PLProcessSimulator):
+        iter_var = node.target.id
+        with get_source_code(src, node.iter) as iter_over:
+            unique_int = uuid1().int
+            tmp = f"v{unique_int}"
+            exec(f"{tmp} = {iter_over}", scope)
+            for buff in scope[tmp]:
+                # update the iteration variable in scope
+                scope[iter_var] = buff
+                PLProcessReader.execute_scope(node.body, scope, runtime_vars, src, devices, plp)
+            # after finishing everything in for-loop finalize the break-nodes, that occurred in it
+            while scope['_break_nodes']:
+                # we have to iterate in a first-in->first-out fashion to respect the python syntax:
+                # pop() pops the last element
+                break_node = scope['_break_nodes'].pop()
+                plp.finalize_break_node(break_node)
+
+    @staticmethod
+    def handle_break(scope: Dict[str, Any], plp: PLProcessSimulator):
+        # create a new break-node
+        break_node = plp.add_break_node()
+        # add it to the hidden list in scope (append adds in the end of the list)
+        scope["_break_nodes"].append(break_node)
+
+
+class PLProcessSimulator(PLProcess, ABC):
+    """
+    A utility class to help going through actions in a PythonLabProcess while linking them correctly.
+    This is done by systematically recursively exploring the abstract syntax tree and executing all
+    functions of ServiceResources while keeping track of the labware. Each call of a function of a ServiceResource
+    adds a new process step node to the workflow graph. The edges are determined by consecutive participation of labware
+    in two steps.
+    """
+    def __init__(self, process_type: Type[PLProcess]):
+        self.workflow = nx.DiGraph()  # this graph will represent the whole experiment
+        self.last_job = {}  # dictionary providing a list of current nodes of each sample in the workflow graph
+        self.last_action = {}  # dictionary providing the last action added id of each labware in the workflow graph
+        self.label_to_node = {}
+        process_type.__init__(self)
+
+    def visualize_workflow_graph(self, show=True):
+        dot = graphviz.Digraph(comment="Workflow")
+        dot.attr(rankdir='LR')
+        node_col = dict(labware='grey', operation='red', if_node="yellow", variable='blue', computation='cyan')
+        for n, data in self.workflow.nodes(data=True):
+            dot.node(str(n), data['name'], color=node_col[data['type']], style='filled')
+        for u, v in self.workflow.edges():
+            dot.edge(str(u), str(v), '')
+        dot.format = "png"
+        dot.render("workflow", view=show)
+        return dot
+
+    def set_starting_position(self, resource: LabwareResource, device: ServiceResource, position: int):
+        # the list of last_job is supposed to have only one entry at this point
+        start_position = self.last_job[resource.name][0]
+        cur_job = self.workflow.nodes[start_position]
+        cur_job['origin_pos'] = position
+        cur_job['origin'] = device.name
+        cur_job['origin_type'] = type(device)
+        cur_job['lidded'] = resource.lidded
+        if isinstance(resource, DynamicLabwareResource):
+            cur_job['is_reagent'] = True
+        # copy all keyword arguments into the workflow node
+        for key, val in resource.kwargs.items():
+            cur_job[key] = val
+
+    def register_labware_resource(self, resource):
+        super().register_labware_resource(resource)
+        # add a workflow node marking the start of the resources journey
+        new_node = self.add_node(dict(type='labware', name=resource.name))
+        # these are used in the construction of the wfg
+        self.last_job[resource.name] = [new_node]
+        self.last_action[resource.name] = -1
+        self.labware_nodes[resource.name] = new_node
+
+    def handle_labels(self, t,  **kwargs):
+        """
+        Very preliminary handling of relations between process steps independent of labware
+        :param t:
+        :param kwargs:
+        :return:
+        """
+        if "label" in kwargs:
+            self.label_to_node[kwargs['label']] = t
+            logging.debug("label_to_node: ", self.label_to_node)
+        edges = {}
+        if "relations" in kwargs:
+            for relation, label, args in kwargs['relations']:
+                node = self.label_to_node[label]
+                logging.debug(relation, label, node, args)
+                if node not in edges:
+                    edges[node] = dict(wait_cost=1, label=relation, max_wait=float('inf'))
+                if relation == "direct_after":
+                    edges[node]['wait_cost'] = 200
+                if relation == "min_wait":
+                    edges[node]['min_wait'] = args[0]
+                if relation == "max_wait":
+                    edges[node]['max_wait'] = args[0]
+        for node, data in edges.items():
+            self.add_edge(node, t, **data)
+
+    def add_process_step(self, resource: ServiceResource, labware: List[LabwareResource], is_movement: bool = False, **kwargs):
+        if "executor" not in kwargs:
+            kwargs['executor'] = []
+        # if a certain device shall execute this operation, we add its name to the kwargs
+        if resource.name in [r.name for r in self._service_resources]:
+            kwargs['executor'].append(resource)
+        node_attr = dict(cont_names=[c.name for c in labware], type='operation',
+                         name=f"{kwargs['fct']} {', '.join([c.name for c in labware])}",
+                         device_type=type(resource))
+        node_attr.update(kwargs)
+        t = self.add_node(node_attr)
+        self.handle_labels(t, **kwargs)
+        if "reagents" in kwargs:
+            labware = labware + kwargs["reagents"]
+        for labware_piece in labware:
+            max_wait = labware_piece.consume_max_wait()
+            min_wait = labware_piece.consume_min_wait()
+            wait_cost = labware_piece.consume_wait_cost()
+            last = self.last_job[labware_piece.name]
+
+            edge_attr = dict(wait_cost=wait_cost,
+                             cont_name=labware_piece.name,
+                             label='',
+                             max_wait=max_wait if max_wait is not None else float('inf'))
+            # if this is a starting step, these are wait_to_start_costs
+            if any(self.workflow.nodes[l]['type'] == "labware" for l in last):
+                self.workflow.nodes[t]["wait_to_start_costs"] = wait_cost
+
+            if min_wait:
+                edge_attr['min_wait'] = min_wait
+            for s in last:
+                self.add_edge(s, t, **edge_attr)
+            self.last_job[labware_piece.name] = [t]
+            self.last_action[labware_piece.name] = t
+
+    def add_var_nodes(self, *args):
+        last_node = list(self.workflow.nodes)[-1]
+        for var_name in args:
+            new_node = self.add_node(dict(name=var_name, type='variable', var_name=var_name))
+            self.add_edge(last_node, new_node, label='out')
+
+    def add_computation(self, name, var_names, fct_code, needed_scope):
+        # this function will be called at runtime to execute the computation
+        def fct(**kwargs):
+            my_scope = needed_scope.copy()
+            my_scope.update(kwargs)
+            return eval(fct_code, my_scope)
+
+        new_node = self.add_node(dict(type='computation', function=fct, name=name, var_name=name))
+        # link the node to its needed variables
+        for name in var_names:
+            # take the latest of mathing variable nodes
+            var_nodes = [n for n, data in self.workflow.nodes(data=True)
+                         if data['type'] in ['variable', 'computation'] and data['name'] == name]
+            var_node = var_nodes[-1]
+            self.add_edge(var_node, new_node, label='in')
+
+    def add_node(self, attr):
+        n = self.workflow.number_of_nodes()
+        self.workflow.add_nodes_from([(n, attr)])
+        return n
+
+    def add_edge(self, s, t, **kwargs):
+        self.workflow.add_edges_from([(s, t, kwargs)])
+
+    def prepare_true_execution(self, if_node):
+        true_dummy = self.workflow.nodes[if_node]["true_dummy"]
+        for name, state in self.last_job.items():
+            self.last_job[name] = [true_dummy]
+
+    def prepare_false_execution(self, if_node):
+        false_dummy = self.workflow.nodes[if_node]["false_dummy"]
+        for name, state in self.last_job.items():
+            self.last_job[name] = [false_dummy]
+
+    # these utility functions are used for example in parsing if-statements
+    def get_state(self):
+        return self.last_job.copy()
+
+    def set_state(self, status):
+        self.last_job = status.copy()
+
+    def join_state(self, status):
+        for n, l in self.last_job.items():
+            l.extend(status[n])
+            self.last_job[n] = list(set(l))
+
+    def add_if_node(self, var_names, decision_code, needed_scope):
+        # this function will be called at runtime to evaluate the decision
+        def fct(**kwargs):
+            my_scope = needed_scope.copy()
+            my_scope.update(kwargs)
+            return eval(decision_code, my_scope)
+
+        true_dummy = self.add_node(dict(type="dummy", name="true dummy"))
+        false_dummy = self.add_node(dict(type="dummy", name="false dummy"))
+        new_node = self.add_node(dict(type="if_node", name=decision_code, function=fct, true_dummy=true_dummy,
+                                      false_dummy=false_dummy))
+
+        self.add_edge(new_node, true_dummy, sub_tree=True, label="True")
+        self.add_edge(new_node, false_dummy, sub_tree=False, label="False")
+
+        # link the node to its needed variables
+        for name in var_names:
+            # take the latest of mathing variable nodes
+            var_nodes = [n for n, data in self.workflow.nodes(data=True)
+                         if data['type'] in ['variable', 'computation'] and data['name'] == name]
+            var_node = var_nodes[-1]
+            self.add_edge(var_node, new_node, label='in')
+        return new_node
+
+    def finalize_if_construction(self, if_node, orig_state, last_break=-1):
+        for cont, last in self.last_job.items():
+            # check whether some actions have been added to this labware since the if_node creation
+            if self.last_action[cont] < if_node:
+                # check for break nodes in the scope of this if clause
+                if last_break > if_node:
+                    self.workflow.nodes[last_break]['if_nodes'].insert(0, (orig_state[cont], if_node, cont))
+                else:
+                    self.last_job[cont] = orig_state[cont].copy()
+            else:
+                for old in orig_state[cont]:
+                    self.add_edge(old, if_node, label='', cont_name=cont)
+
+    def add_break_node(self):
+        # the only thing a break node needs is a copy of the current state
+        new_node = self.add_node(dict(type="dummy", name='break', cur_state=deepcopy(self.last_job), if_nodes=[]))
+        for cont in self.last_job:
+            self.last_job[cont] = []
+        return new_node
+
+    def finalize_break_node(self, break_node):
+        # check for every labware whether something has changed since creating the break node
+        before_break = self.workflow.nodes[break_node]['cur_state']
+        for cont, last_action in self.last_action.items():
+            if last_action > break_node:
+                for old in before_break[cont]:
+                    self.add_edge(old, break_node, label='', cont_name=cont)
+                self.last_job[cont].append(break_node)
+            else:
+                self.last_job[cont] = before_break[cont].copy()
+        for orig_state, if_node, cont in self.workflow.nodes[break_node]['if_nodes']:
+            if self.last_action[cont] > if_node:
+                for old in orig_state:
+                    self.add_edge(old, if_node, label='', cont_name=cont)
+            else:
+                self.last_job[cont] = orig_state.copy()

pythonlab/resource.py

@@ -0,0 +1,248 @@
+"""_____________________________________________________________________
+
+:PROJECT: pythonLab
+
+*resource base classes*
+
+:details:
+
+:authors: mark doerr (mark@uni-greifswald.de)
+
+:date: (creation)          20210410
+
+________________________________________________________________________
+
+"""
+
+__version__ = "0.0.1"
+
+import importlib
+import logging
+import pkgutil
+from enum import Enum
+#from labdatareader.data_reader import DataReader
+from typing import Optional
+
+from abc import ABC, abstractmethod
+
+
+class DataDirection(Enum):
+    data_in = 1
+    data_out = 2
+
+
+class DataType(Enum):
+    single_value = 1  # scalar
+    structured_data = 2  # list, dict, or larger
+    data_stream = 3
+
+
+class Position:
+    def __init__(self, resource, position: int):
+        self._resource = resource
+        self._postion = position
+        self._postion_name = f"{str(resource.name)}_{str(position)}"
+
+    @property
+    def pos(self):
+        return self._postion
+
+    @property
+    def resource(self):
+        return self._resource
+
+    @property
+    def name(self):
+        return self._postion_name
+
+
+class Resource(ABC):
+    def __init__(self,
+                 proc=None,
+                 name: Optional[str] = None):
+        self.proc = proc
+        self._name = name
+
+        self.auto_register_resource()
+
+    @abstractmethod
+    def init(self):
+        raise NotImplementedError
+
+    def auto_register_resource(self):
+        """auto register resource in corresponding process
+        """
+        if isinstance(self, ServiceResource):
+            self.proc.register_service_resource(self)
+        elif isinstance(self, LabwareResource):
+            self.proc.register_labware_resource(self)
+        elif isinstance(self, DynamicLabwareResource):
+            self.proc.register_labware_resource(self)
+        elif isinstance(self, SubstanceResource):
+            self.proc.register_substance_resource(self)
+        elif isinstance(self, DataResource):
+            self.proc.register_data_resource(self)
+
+    def import_resources(self, path):
+        """Import resources from a given path
+
+        :param path: _description_
+        :type path: _type_
+        TODO: path to resources
+        """
+        #TODO: Mark: What went wrong here?
+        #self._import_all_resources("TDOO: path to resource definitions")
+
+    def _import_all_resources(self, namespace_pkg):
+        """
+        recursively iterate through namespace
+        Specifying the second argument (prefix) to iter_modules makes the
+        returned name an absolute name instead of a relative one. This allows
+        import_module to work without having to do additional modification to
+        the name.
+        s. https://packaging.python.org/guides/creating-and-discovering-plugins/
+
+        TODO: recursive import !!
+        """
+        for finder, name, ispkg in pkgutil.iter_modules(namespace_pkg.__path__, namespace_pkg.__name__ + "."):
+            submodule = importlib.import_module(name)
+            if ispkg:
+                self._import_all_resources(submodule)
+                # if a dictionary of discovered plugins is required, see LabDataReader
+
+    @property
+    def name(self):
+        return self._name
+
+
+class ServiceResource(Resource):
+    """ServiceResource
+       is reflection SiLA's service oriented concept
+       (more general than a device, since a service can be much more than a device)
+
+    :param Resource: [description]
+    :type Resource: [type]
+    """
+
+    def __init__(self,
+                 proc,
+                 name: Optional[str] = None):
+        super().__init__(proc=proc, name=name)
+
+    def init(self):
+        pass
+
+
+class LabwareResource(Resource):
+    """
+      multi-cavity / single cavity ?
+      associated labware, like labwares, lids, stacks
+
+    :param Resource: [description]
+    :type Resource: [type]
+    """
+
+    def __init__(self,
+                 proc,
+                 name: str = None,
+                 priority=None,
+                 lidded: bool = False,
+                 **kwargs):
+        super().__init__(proc=proc, name=name)
+        self._position = None
+        self.priority = priority
+        self.start_position = None
+        # this flag can be set in a process and will be 'consumed' when the next step with this labware is called
+        self._max_wait = None
+        self._min_wait = None
+        self._wait_cost = 0
+        self.lidded = lidded
+        self.kwargs = kwargs
+
+    def init(self):
+        logging.debug(f"init {self.name}")
+
+    # returns the maximum waiting time until next step and resets it
+    def consume_max_wait(self):
+        tmp = self._max_wait
+        self._max_wait = None
+        return tmp
+
+    def max_wait(self, duration):
+        self._max_wait = duration
+
+    def min_wait(self, duration):
+        self._min_wait = duration
+
+    def consume_min_wait(self):
+        tmp = self._min_wait
+        self._min_wait = None
+        return tmp
+
+    # returns the cost for waiting until next step and resets it
+    def consume_wait_cost(self):
+        tmp = self._wait_cost
+        self._wait_cost = 0
+        return tmp
+
+    def wait_cost(self, cost_per_second):
+        self._wait_cost = cost_per_second
+
+    def set_start_position(self, resource, position):
+        self._position = Position(resource=resource, position=position)
+        self.start_position = self._position
+        self.proc.set_starting_position(self, resource, position)
+
+    @property
+    def pos(self):
+        return self._position
+
+
+class DynamicLabwareResource(LabwareResource):
+    def __init__(self, proc, name: str, priority=None, lidded: bool = False, outside_cost=0, **kwargs):
+        """Dynamic Labware is a special type of labware, where order of usage is (dynamically) determined during the process execution,
+        e.g. a reagent trough that is used when addition of a reagent to a certain labware is required, depending on an outcome of a descision,
+        like a pH measurement or induction after a certain Absorbtion is reached.
+
+        :param proc:
+        :param name:
+        :param priority:
+        :param lidded:
+        :param outside_cost: Some reagents need to be stored under special properties (e.g. cooled). These costs get
+                             translated to waiting_costs between getting it out and putting it back
+        :param kwargs:
+        """
+        super().__init__(proc, name=name, priority=priority, lidded=lidded, **kwargs)
+        self.outside_cost = outside_cost
+
+
+class SubstanceResource(Resource):
+    """SubstanceResource
+       more general concept than sample
+       can be used to define substances / samples and their corresponding properties,
+       like liquid classes, or physical state (gas, liquid, solid/powder),
+       density, viscosity, vapour pressure
+
+    :param Resource: [description]
+    :type Resource: [type]
+    """
+
+    def init(self):
+        pass
+
+    def __init__(self,
+                 proc,
+                 name: str = None):
+        super().__init__(proc=proc, name=name)
+
+
+class DataResource(Resource):
+    def init(self):
+        pass
+
+    def __init__(self,
+                 proc,
+                 name: str = None):
+        super().__init__(proc=proc, name=name)
+
+        self.direction = None  # DataDirection.data_in

uupythonlab-0.2.4.dist-info/METADATA

@@ -0,0 +1,232 @@
+Metadata-Version: 2.4
+Name: uuPythonlab
+Version: 0.2.4
+License-Expression: MIT
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS.md
+Requires-Dist: graphviz
+Requires-Dist: networkx
+Dynamic: license-file
+
+# pythonLab
+
+This is the specification and development repository of
+**pythonLab**, a universal, extendable and safe language for laboratory processes.
+
+Reproducibility and reliability is in the core of science.
+Describing lab operations in an precise, easy and standardised form will help to transfer knowledge in every lab around the world.
+A *laboratory process description language* is a long desired goal in laboratory process standardisation and lab automation.
+It will enable automated execution of steps and better machine learning and AI predictions, since these process descriptions can be packed as metadata to the data resulting form this process.   
+
+Since this process language needs many characteristics of a programming language, like conditions (if ...), loops (for/while), variables, etc. we do not want to re-invent the wheel twice but rather use the **python syntax**, which is very popular in science. 
+
+## Key (desired) Features 
+
+  * easy and simple to learn and write (close to simple English)
+  * clear, human readable syntax
+  * universal - applicable for most laboratory operations
+  * transferable from one lab to another
+  * easy mapping between abstract resource representation and actual lab resource
+  * [*Turing-complete*](https://en.wikipedia.org/wiki/Turing_completeness), including conditions and loops
+  * easy extendible - prepared for the constant development of science
+  * close to real laboratory work
+  * vendor independent
+  * safe to execute
+  * converter from other lab description languages to pythonLab easy to implement
+
+## Applications of pythonLab
+
+  * general lab processes, common in any natural sciences lab (very broad application)
+  * description of lab automation workflows
+  * workflows on the lab devices (e.g. HPLC processes - sometimes also called 'methods', plate reader processes etc.)
+  * data evaluation workflows
+
+## Architecture of pythonLab
+
+pythonLab processes are denoted in a python like syntax, but they are **not** directly executed by a *python interpreter*. They are rather parsed into a *workflow graph*, which can be used by a *Scheduler* to calculate 
+an optimal schedule (=order of execution). This order of execution might be different from the initial notation. An *Orchestrator* executes then the schedule and supervises the device communication, e.g. to SiLA servers/devices.
+
+![pythonLab Architecture](docs/images/pythonLab_architecture_overview.svg)
+
+## [Specification](https://opensourcelab.gitlab.io/pythonLab/specification/0_specification_base.html)
+
+Please find a draft of the pythonLab specification in [docs/specification](https://pythonlabor.gitlab.io/pythonLab/specification/specification.html) (very early stage !).
+
+Very briefly, the generic lab description language should have many features a common programming language has and following the desired *Turning-completeness*, like:  
+
+- variables  (x = value)
+- conditions (if, else, ...)
+- loops      (for ... while ....)
+- functions / methods and subroutines 
+- modules
+- namespaces and versions for unique addressing of a process step
+- (at a later stage of language development: object orientation)
+
+**!! This is a proposal - we would like to discuss it with a wide range of scientist to find the best common ground** 
+
+## [Documentation](https://opensourcelab.gitlab.io/pythonLab/)
+
+The pythonLab Documentation can be found in [docs](https://pythonlabor.gitlab.io/pythonLab/)
+
+## Language Core extensions
+
+extensible Modules for e.g.
+- liquid handling
+- cultivation
+- (bio-chemical) assays
+- molecular biology
+- chemical synthesis
+- data evaluation
+
+are in preparation
+
+
+## Examples
+
+A simple description of liquid transfer step
+
+```python
+
+# using settings: volume unit: uL, liquid class: water
+# these are set in a settings module
+# specifying resources
+from pythonlab.resource import LabwareResource, DeviceResource
+from pythonlab.liquid_handling import aspirate, dispense
+
+cont1 = LabwareResource()
+cont2 = LabwareResource()          
+liquid_handler = DeviceResource()
+
+# process steps
+liquid_handler.aspirate(cont1, row=1, col=3, vol=4.0)
+liquid_handler.dispense(cont2, row=2, col=3 , vol=7.2)
+...
+
+```
+
+A bit more complex example
+
+```python
+# default units (SI) are specified in the standard unit module
+# additional unit definitions can be added in the code  
+# specifying resources
+
+from pythonlab.resource.labware import LabwareResource
+from pythonlab.resource.services import MoverServiceResource, IncubationServiceResource
+
+cont1 = LabwareResource()
+mover = MoverServiceResource()
+incubator = IncubationServiceResource()
+start_pos = cont1.set_start_position(pos=1)
+incubation_duration = 6 # hours
+
+# initialise the process 
+incubator.init()
+# process steps
+mover.move(cont1,  start_pos, incubator.nest1)
+incubator.incubate(cont1, incubation_duration, unit="h")
+mover.move(cont1, incubator.nest1, start_pos)
+
+
+...
+
+```
+
+And finally a higher level example
+
+```python
+# default units (SI) are specified in the standard unit module
+# additional unit definitions can be added in the code  
+# specifying resources
+
+from pythonlab.resource.labware import LabwareResource
+from pythonlab.resource.services import MoverServiceResource, DispensionServiceResource, IncubationServiceResource
+
+from pythonlab.processes.base import incubate, centrifugate
+from pythonlab.bioprocess import inoculate
+
+Labware_set = [LabwareResource(name=f"growth_plate_{cont}")
+                           for cont in range(8)]
+
+dispenser = DispensionServiceResource()
+incubator = IncubationServiceResource()
+
+inoculate([dispenser, Labware_set], source="starting_culture")
+incubate([incubator, Labware_set], temp=310.0, shaking=(700,2) )  # temp in K
+centrifugate([incubator, Labware_set], duration=600, force=4500)
+
+...
+
+```
+## Why python ?
+
+Python is a programming language that is very common in modern scientific laboratories and covers all the desired characteristics we expect of a user-friendly lab process programming language.
+
+The syntax is very simple, and intuitive to learn.
+Syntax validation comes for free: the python interpreter already does it.
+
+Standardisation of a minimal set of functionally will be achieved by standardised packages provided by this site (or any publicly available site).
+Defined namespaces and versioning allow unique addressing of a process step. 
+
+
+## [Implementation](./implementation)
+
+As a proof-of-concept we are planning to provide a [pypy-sandbox](https://www.pypy.org) implementation in the future.
+[pypy-sandbox](https://www.pypy.org) offerers a safe execution environment to execute insecure code. 
+A new version is currently developed to by the pypy community.
+Alternatively WASM will be a possible safe execution environment.
+
+## Related projects
+
+Here is an incomplete list of related OpenSource projects - please let us know, if we missed a relevant project. 
+
+###  [Autoprotocoll](http://autoprotocol.org)
+
+  * Syntax: JSON based 
+  * (-) not *Turing complete*
+  * (-) hard to write and read by humans
+
+###  [LabOP](https://bioprotocols.github.io/labop/)
+
+  * Syntax: RDF / python
+  * (-) not *Turing complete* (?)
+  * (-) hard to write and read by humans
+
+### [RoboLiq](https://ellis.github.io/roboliq/protocol/index.html)
+
+  * Syntax: yaml / Javascript
+  * (-) not *Turing complete*
+  * (-) hard to write and read by humans
+  * (-) design not clearly specified
+
+## Repository Maintainer:
+
+* mark doerr (mark.doerr@uni-greifswald.de)
+
+## Documentation
+
+The Documentation can be found here: [opensourcelab.gitlab.io/pythonLab](opensourcelab.gitlab.io/pythonLab) or [pythonLab.gitlab.io](pythonlab.gitlab.io/)
+
+
+## Credits
+
+This package was created with Cookiecutter* and the `opensource/templates/cookiecutter-pypackage`* project template.
+
+[Cookiecutter](https://github.com/audreyr/cookiecutter )
+[opensource/templates/cookiecutter-pypackage](https://gitlab.com/opensourcelab/software-dev/cookiecutter-pypackage) 

uupythonlab-0.2.4.dist-info/RECORD

@@ -0,0 +1,10 @@
+pythonlab/__init__.py,sha256=VFiH6ZP26gn4WR58bwTy09VKZij0PveXdSnpLleZppk,135
+pythonlab/process.py,sha256=tPyIjvDTIW99PwTEXxvvoX9140xGY8lAe19hotYjPRk,4030
+pythonlab/pythonlab_reader.py,sha256=Nx3C6gkUuSIHu5AveklSXpKIV5I1CsN1DzAgzF5ncwA,23530
+pythonlab/resource.py,sha256=SQl_caY0zrLfPVWMGz-UqFSzG9Dqm0-YZzgg6MEK7-k,7248
+uupythonlab-0.2.4.dist-info/licenses/AUTHORS.md,sha256=0CKaSdSK_ra16Aj2vOKukvEHkwRVn2sIena6m12LTxM,319
+uupythonlab-0.2.4.dist-info/licenses/LICENSE,sha256=roQhQQq7QavJXjo0M5pQwzHQ9kF46SYKfEE8tEFuym8,1069
+uupythonlab-0.2.4.dist-info/METADATA,sha256=xp-TYs23C596kLgSehDdv299YPgs36_7hR1D4AQLb84,8898
+uupythonlab-0.2.4.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+uupythonlab-0.2.4.dist-info/top_level.txt,sha256=bMSAdzhhv_tcLTrP7VJbE7PsLvEJxh6_HU_B38rXPcA,10
+uupythonlab-0.2.4.dist-info/RECORD,,

uupythonlab-0.2.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

uupythonlab-0.2.4.dist-info/licenses/AUTHORS.md

@@ -0,0 +1,17 @@
+
+# Acknowledgements and Credits
+
+The pythonLab project thanks
+
+
+Contributors
+------------
+
+* Stefan Maak <stefan.maak@uni-greifswald.de>
+* Mickey Kim <mickey.kim@genomicsengland.co.uk>  ! Thanks for the phantastic cookiecutter template !
+
+
+Development Lead
+----------------
+
+* mark doerr <mark.doerr@uni-greifswald.de>

uupythonlab-0.2.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022, mark doerr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

uupythonlab-0.2.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+pythonlab