wirely 0.1.0__py3-none-any.whl

wirely/block.py

@@ -0,0 +1,542 @@
+import abc
+
+import wirely as blocks
+from wirely.util import check_parameters
+
+# TODO: Rename this to BlockInstantiation or BlockUsage?
+# TODO: Probably Input, Output, StateVariable etc. should be moved out of this and only exist in BlockType
+class Block(blocks.Node):
+    def __init__(self, graph, *, name, block_type, par_values, instantiation):
+        super().__init__(graph=graph, name=name)
+
+        self.block_type = block_type
+        self.par_values = par_values
+        self.instantiation = instantiation
+        # TODO: Clean up
+        for par in self.par_values:
+            val = self.par_values[par]
+            if not isinstance(val, blocks.ValueParameter) and not isinstance(val, blocks.Value) and not isinstance(val, blocks.Type):
+               raise Exception(f'Got invalid parameter value: {val}')
+            # TODO: Also check for contains_parameters? When should this be done?
+            # if val.contains_parameters:
+            #    raise Exception(f'Got parameter value {val} contains parameters')
+
+        # TODO: A lot of this stuff should be moved to BlockType, instead the Block instance should only store the connections to the BlockType's inputs and from the BlockType's outputs
+        self.block_inputs = []
+        self.block_outputs = []
+        self.block_inputs_byname = {}
+        self.block_outputs_byname = {}
+        self.block_temporaries = []
+        self.block_statevars = []
+        self.block_procedures = []
+        self.last_proc_id = 0
+
+        if self.name in self.graph.blocks:
+            raise Exception(f'Duplicate block name {self.name!r}')
+        self.graph.blocks[self.name] = self
+
+    def __repr__(self):
+        # return f"{type(self).__name__}{{{self.graph}.{self.name}}}"
+        return f"{self.graph}.{self.name}[{type(self).__name__}]"
+
+    def __str__(self):
+        return f"{self.graph}.{self.name}"
+
+    def validate(self):
+        for input in self.all_block_inputs:
+            if input.connected_source is None:
+                # TODO: Hack
+                if isinstance(input.block, blocks.BlockOutput):
+                    continue
+                raise Exception(f'Input {self.graph}.{self.name}.{input.name} is not connected')
+
+        for output in self.block_outputs:
+            if output.temporary.producer is None:
+                # TODO: Hack
+                if isinstance(output.temporary.block, blocks.BlockInput):
+                    continue
+                raise Exception(f'Output {self.graph}.{self.name}.{output.name} has no producer')
+
+    def create_native_state(self, path, engine, static_block_context):
+        if path[-1] != self:
+            raise Exception('path[-1] != self')
+        # TODO
+        if hasattr(self, 'block_type') and hasattr(self.block_type, 'is_native'):
+            if self.block_type.is_native:
+                # print('QQQ', self.name)
+                return self.native_class(path, engine, static_block_context=static_block_context)
+            else:
+                # print('WWW', self.name)
+                pass
+
+        return None
+
+    # TODO: Clean up
+    @property
+    def all_block_inputs(self):
+        res = []
+        for input in self.block_inputs:
+            if input.is_list:
+                # TODO: Currently the individual entries of the list are already in block_inputs
+                # res += input.members
+                pass
+            else:
+                res.append(input)
+        return res
+
+    # TODO: Rename
+    # TODO: Must probably be cleaned up to allow multiple instantiations of the same block
+    # path: A tuple which contains the name of the block being instantiated
+    def instantiate(self, *, singletons, add_var, variable_map, state_map_new, all_variables, state_map_changed, state_map, state_variables, instances, path, parent_instance):
+        if self.block_type.is_singleton:
+            if self.block_type in singletons:
+                return
+
+            # TODO: This probably should not need an instance of Block here
+            singletons[self.block_type] = self
+
+            # TODO: This is an ugly hack, remove
+            if hasattr(self.block_type, 'singleton_instance'):
+                raise Exception("hasattr(self.block_type, 'singleton_instance')")
+            # print(f'Using {self} as instance for {self.block_type}')
+            self.block_type.singleton_instance = self
+
+            path = (self.block_type,)
+
+        if self.block_type.is_singleton:
+            instance = blocks.BlockInstance(self.block_type, parent_instance=None)
+        else:
+            instance = blocks.BlockInstance(self, parent_instance=parent_instance)
+
+        if path != instance.path:
+            raise Exception(f'path {path} != instance.path {instance.path}')
+
+        if instance.path in instances:
+            raise Exception(f'Duplicate path {path}')
+        instances[instance.path] = instance
+
+        for name, child_block in self.block_type.blocks.items():
+            child_path = path + (child_block,)
+            child_block.instantiate(singletons=singletons, add_var=add_var, variable_map=variable_map, state_map_new=state_map_new, all_variables=all_variables, state_map_changed=state_map_changed, state_map=state_map, state_variables=state_variables, instances=instances, path=child_path, parent_instance=instance)
+
+        # TODO: Clean up
+        # path_prefix = '.'.join([block.name for block in path])
+        path_prefix = '.'.join([(block.name if isinstance(block, blocks.Block) else block.name.id_str) for block in path])
+        for state_var in self.block_statevars:
+            v = blocks.Variable(path_prefix + '.' + state_var.name + '.new', state_var.var_type)
+            state_map_new[path, state_var] = v
+            all_variables.append(v)
+
+            v = blocks.Variable(path_prefix + '.' + state_var.name + '.changed', blocks.types.boolean)
+            state_map_changed[path, state_var] = v
+            all_variables.append(v)
+
+            v = blocks.Variable(path_prefix + '.' + state_var.name, state_var.var_type)
+            state_map[path, state_var] = v
+            state_variables.append(v)
+        for var in self.all_block_inputs:
+            if var.var_type is None:
+                continue
+            variable_map[path, var.var_identifier] = add_var(*blocks.resolve_variable(path, var))
+        for var in self.block_outputs:
+            if var.var_type is None:
+                continue
+            variable_map[path, var.var_identifier] = add_var(*blocks.resolve_variable(path, var))
+        for var in self.block_temporaries:
+            variable_map[path, var.var_identifier] = add_var(*blocks.resolve_variable(path, var))
+
+    # TODO: Probably should be merged into instantiate()
+    def get_block_procedures_paths(self, prefix):
+        # TODO: Handle singletons properly?
+        res = [(blocks.path_resolve_singleton(prefix + (self,)), proc) for proc in self.block_procedures]
+        for child_block in self.block_type.blocks.values():
+            res += child_block.get_block_procedures_paths(prefix + (self,))
+        return res
+
+    # TODO: Probably should be merged into instantiate()
+    def get_all_block_paths(self, prefix):
+        # TODO: Handle singletons properly?
+        res = [blocks.path_resolve_singleton(prefix + (self,))]
+        for child_block in self.block_type.blocks.values():
+            res += child_block.get_all_block_paths(prefix + (self,))
+        return res
+
+    class Member(abc.ABC):
+        def __init__(self, block: 'Block', name: str):
+            if not isinstance(block, Block):
+                raise Exception('block parameter is not a Block')
+            if not isinstance(name, str):
+                raise Exception('name parameter is not a str')
+            name = str(name)
+
+            self.block = block
+            self.name = name
+
+        def __repr__(self):
+            return f"{self.block}.{self.name}"
+
+    # TODO: Move out of block class / Remove Member parent?
+    class Source(Member, abc.ABC):
+        @property
+        @abc.abstractmethod
+        def temporary(self):
+            ...
+
+    # TODO: Move out of block class / Remove Member parent?
+    class Target(Member, abc.ABC):
+        pass
+
+    # TODO: Handle var_type == None better
+    # TODO: Clean up, move more functionality to BlockInput
+    class Input(Source):
+        def __init__(self, block: 'Block', name: str, is_list: bool, var_type: blocks.types.Type, *, block_input: blocks.BlockInput):
+            Block.Member.__init__(self, block, name)
+            if not isinstance(is_list, bool):
+                raise Exception('is_list parameter is not of type bool')
+            if var_type is not None and not isinstance(var_type, blocks.types.Type):
+                raise Exception('var_type parameter is not a Type')
+
+            self.is_list = bool(is_list)
+            self.var_type = var_type
+            self.block_input = block_input
+
+            self.conn_spec = self.block_input.conn_spec
+
+            if isinstance(self.conn_spec, blocks.ConnectorSpecificationData):
+                if self.conn_spec.kind_spec.kind == blocks.ConnectionKind.Value:
+                    self.impl_var_type = self.var_type
+                elif self.conn_spec.kind_spec.kind == blocks.ConnectionKind.Event:
+                    self.impl_var_type = blocks.types.TypeOption(self.var_type)
+                else:
+                    raise Exception(f'Unknown ConnectionKind: {self.conn_spec.kind_spec.kind}')
+            else:
+                # TODO: ?
+                self.impl_var_type = None
+
+            if self.is_list:
+                self.members = []
+            else:
+                self.connected_source = None
+
+            self.block.block_inputs.append(self)
+            if self.name in self.block.block_inputs_byname:
+                raise Exception(f'Duplicate input name {name!r}')
+            self.block.block_inputs_byname[self.name] = self
+
+        def __repr__(self):
+            return f"{self.block}.{self.name}"
+
+        @property
+        def temporary(self):
+            if self.is_list:
+                raise Exception('Trying to get temporary for list')
+            if self.connected_source is None:
+                raise Exception(f'{self} is not connected')
+            # TODO: Cache multiple follows?
+            return self.connected_source.temporary
+
+        def connect(self, output):
+            # TODO: Clean up class structure for value sources / targets
+            if not isinstance(output, Block.Output) and not isinstance(output, blocks.BlockInput) and not isinstance(output, blocks.BlockStateVariable) and not isinstance(output, blocks.BlockTemporaryVariable):
+                raise Exception('output parameter value is not an Output instance and not a BlockInput, BlockStateVariable or BlockTemporaryVariable')
+            if self.is_list:
+                # TODO: Clean up
+                # TODO: What should be used for block_input here?
+                input = Block.Input(self.block, f'{self.name}.{len(self.members)}', False, self.var_type, block_input=self)
+                input.connect(output)
+                self.members.append(input)
+            else:
+                if self.connected_source is not None:
+                    raise Exception(f'{self} is already connected to {self.connected_source}, trying to connect to {output}')
+
+                self.connected_source = output
+
+        # TODO: Remove and replace with self, Input should contains a reference to BlockType, not to Block
+        @property
+        def var_identifier(self):
+            return 'INP ' + self.block.block_type.name.id_str + '.' + self.name
+
+    # TODO: Handle var_type == None better
+    # TODO: Clean up, move more functionality to BlockOutput
+    class Output(Target):
+        # TODO: Allow creating Output without Temporary?
+        def __init__(self, block: 'Block', name: str, var_type: blocks.types.Type, input_dependencies=[], *, block_output: blocks.BlockOutput):
+            Block.Member.__init__(self, block, name)
+            if var_type is not None and not isinstance(var_type, blocks.types.Type):
+                raise Exception('var_type parameter is not a Type')
+
+            self.var_type = var_type
+            self.block_output = block_output
+
+            self.conn_spec = self.block_output.conn_spec
+
+            if isinstance(self.conn_spec, blocks.ConnectorSpecificationData):
+                if self.conn_spec.kind_spec.kind == blocks.ConnectionKind.Value:
+                    self.impl_var_type = self.var_type
+                elif self.conn_spec.kind_spec.kind == blocks.ConnectionKind.Event:
+                    self.impl_var_type = blocks.types.TypeOption(self.var_type)
+                else:
+                    raise Exception(f'Unknown ConnectionKind: {self.conn_spec.kind_spec.kind}')
+            else:
+                # TODO: ?
+                self.impl_var_type = None
+
+            self.input_dependencies = []
+            for dependency in input_dependencies:
+                if not isinstance(dependency, Block.Input):
+                    raise Exception('input_dependencies parameter value is not an Input instance')
+                if dependency.block != self.block:
+                    raise Exception('input_dependencies parameter value is for another block')
+                self.input_dependencies.append(dependency)
+
+            if self.var_type is not None:
+                self.temporary = Block.Temporary(block, name + '_val', var_type, impl_var_type=self.impl_var_type)
+                # TODO: Hack
+                self.orig_temporary = self.temporary
+
+            self.block.block_outputs.append(self)
+            if self.name in self.block.block_outputs_byname:
+                raise Exception(f'Duplicate output name {name!r}')
+            self.block.block_outputs_byname[self.name] = self
+
+        @property
+        def name_desc(self):
+            if self.name == '':
+                return 'implicit output'
+            else:
+                return self.name
+
+        def __repr__(self):
+            return f"{self.block}.{self.name}"
+
+        # TODO: Remove and replace with self, Output should contains a reference to BlockType, not to Block
+        @property
+        def var_identifier(self):
+            return 'OUT ' + self.block.block_type.name.id_str + '.' + self.name
+
+    # TODO: Allow both temporaries and output values to be references to other values
+    class Temporary(Source, Target):
+        def __init__(self, block: 'Block', name: str, var_type: blocks.types.Type, *, impl_var_type):
+            Block.Member.__init__(self, block, name)
+            if not isinstance(var_type, blocks.types.Type):
+                raise Exception('var_type parameter is not a Type')
+
+            self.var_type = var_type
+
+            self.impl_var_type = impl_var_type
+
+            self.producer = None
+
+            self.block.block_temporaries.append(self)
+
+        def __repr__(self):
+            return f"{self.block}.{self.name}"
+
+        @property
+        def temporary(self):
+            return self
+
+        # TODO: Remove and replace with self, Temporary should contains a reference to BlockType, not to Block
+        @property
+        def var_identifier(self):
+            return 'TEMP ' + self.block.block_type.name.id_str + '.' + self.name
+
+    class StateVariable(Source, Target):
+        def __init__(self, block: 'Block', name: str, var_type: blocks.types.Type, initial_value):
+            Block.Member.__init__(self, block, name)
+            if not isinstance(var_type, blocks.types.Type):
+                raise Exception('var_type parameter is not a Type')
+
+            self.var_type = var_type
+            self.initial_value = self.var_type.verify_value(initial_value)
+
+            self.impl_var_type = self.var_type
+
+            self.producer = None
+
+            self.block.block_statevars.append(self)
+
+        def __repr__(self):
+            return f"StateVariable[{self}]"
+
+        def __str__(self):
+            return f"{self.block}.{self.name}"
+
+        # TODO
+        @property
+        def temporary(self):
+            return self
+
+    class Procedure:
+        # TODO: Make name mandatory
+        def __init__(self, block: 'Block', dependencies, results, impl, can_trigger=False, name=None, *, static_context, declaration_procedure):
+            if not isinstance(block, Block):
+                raise Exception('block parameter is not a Block')
+
+            self.block = block
+            self.name = name
+            self.declaration_procedure = declaration_procedure
+            # TODO: Is this a complete static context? Probably not because the context might also depend on the parameters to the current block. Move this somewhere else?
+            self.static_context = static_context
+
+            self.block.last_proc_id += 1
+            self.id = self.block.last_proc_id
+
+            self.dependencies = []
+            for dependency in dependencies:
+                if not isinstance(dependency, Block.Source):
+                    raise Exception('dependencies parameter value is not an Input or Temporary instance')
+                # TODO: Clean up inheritance
+                # TODO: Allow depending on the new value of the state variable?
+                # TODO: Also make dependency on old value explicit?
+                if isinstance(dependency, Block.StateVariable):
+                    raise Exception('dependencies parameter value is a StateVariable instance')
+                # TODO: Allow dependencies on other blocks? Probably yes. Maybe check where dependency.block is a child of the current block?
+                # if dependency.block != self.block:
+                #     raise Exception('dependencies parameter value is for another block')
+                self.dependencies.append(dependency)
+
+            self.results = []
+            for result in results:
+                if not isinstance(result, Block.Target):
+                    raise Exception(f'results parameter value is not an Output or Temporary instance: {type(result)}')
+                if result.block != self.block:
+                    raise Exception('results parameter value is for another block')
+                self.results.append(result)
+
+                # TODO:  whether dependencies of output include required inputs as dependencies
+
+                # TODO: Clean up temporary / output stuff
+                if result.temporary.producer is not None:
+                    raise Exception(f'{result} already has producer {result.temporary.producer}, got new producer {self}')
+                # print(f'Setting result for {result} / {result.temporary}')
+                result.temporary.producer = self
+
+            self.impl = impl
+            self.can_trigger = can_trigger
+
+            self.block.block_procedures.append(self)
+
+        def __repr__(self):
+            if self.name is not None:
+                return f"{self.block}.{self.name}"
+            else:
+                return f"{self.block}.proc{self.id}"
+
+        # TODO: Remove and replace with self, Procedure should contains a reference to BlockType, not to Block
+        @property
+        def proc_identifier(self):
+            return 'PROC ' + self.block.block_type.name.id_str + '.' + self.name
+
+class BlockInstance(blocks.NodeInstance):
+    @check_parameters
+    def __init__(self, block, parent_instance):
+        if isinstance(block, blocks.Block):
+            super().__init__(block, parent_instance=parent_instance)
+            # Alias for self.node
+            self.block = block
+
+            self.is_singleton = False
+
+            self.block_type = self.block.block_type
+        elif isinstance(block, blocks.BlockType):
+            if parent_instance != None:
+                raise Exception('parent_instance != None')
+            # TODO: Clean up? Create separate type?
+            super().__init__(None, parent_instance=None)
+            self.block = None
+
+            self.is_singleton = True
+
+            self.block_type = block
+        else:
+            raise Exception(f'Unknown value for block: {block}')
+
+        if self.is_singleton:
+            self.parameter_values = {}
+        else:
+            self.parameter_values = dict(self.block.par_values)
+
+            # Resolve parameter values from parent
+            parent_parameter_values = None
+            if self.parent_instance is not None:
+                parent_parameter_values = self.parent_instance.parameter_values
+            # TODO: Do this properly, handle nested parameters etc.
+            for key in list(self.parameter_values):
+                # TODO: Clean up
+                val = self.parameter_values[key]
+                if isinstance(val, blocks.TypeParameter) or isinstance(val, blocks.ValueParameter):
+                    par = val.parameter
+                    if par not in parent_parameter_values:
+                        if key.is_optional:
+                            # TODO: Clean this up. Store a value like None in this case?
+                            del self.parameter_values[key]
+                            continue
+                        raise Exception(f'Could not find parameter {par.name} in parent')
+                    # TODO: Check type etc.
+                    new_val = parent_parameter_values[par]
+                    # print('QQQ', val, new_val)
+                    # TODO: Properly handle type parameters
+                    if isinstance(val, blocks.TypeParameter):
+                        if not isinstance(val, blocks.Type):
+                            # TODO: hints?
+                            raise blocks.ProgramError(val.parameter, f'[TODO: Error message] Got parameter of type {new_val.value_type} for {val.parameter.name} where type parameter was expected')
+                    else:
+                        if val.value_type != new_val.value_type:
+                            # TODO: Fix error message / hints
+                            hints = [
+                                blocks.CompilerHint(val.parameter, 'Parameter is declared here'),
+                            ]
+                            raise blocks.ProgramError(val.parameter, f'[TODO: Error message] Got parameter of type {new_val.value_type} for {val.parameter.name} where parameter of type {val.value_type} expected', hints=hints)
+                    # TODO: Check whether this is fully resolved
+                    self.parameter_values[key] = new_val
+
+        # TODO: Clean this up. Probably other places should also used the parents' parameters
+        # TODO: Also, probably make sure that no parameters have been resolved here? Or should the be resolved as far as possible? Currently they are resolved in a weird way (a direct parameter might be resolved while the same parameter in a function call is not).
+        all_par_values = dict(self.parameter_values)
+        next_parent = self.parent_instance
+        while next_parent is not None:
+            for key in next_parent.parameter_values:
+                if key not in all_par_values:
+                    all_par_values[key] = next_parent.parameter_values[key]
+            next_parent = next_parent.parent_instance
+
+        # print(f'Resolving while creating BlockInstance: {self.parameter_values} /// {all_par_values}')
+        # TODO: Store this?
+        parameter_values_resolved = {key: value.resolve_self(par_values=all_par_values) for key, value in self.parameter_values.items()}
+
+        parameter_values_bystr = {key.name.id_str: value for key, value in parameter_values_resolved.items()}
+        native_class = self.block_type.native_class
+        parsed_native_instance = None
+
+        # TODO: Pass this differently
+        parameter_values_bystr[''] = {}
+        if self.block is None:
+            # Singleton
+            parameter_values_bystr['']['BlkFilename'] = None
+        else:
+            # TODO: Get the filename from somewhere else?
+            parameter_values_bystr['']['BlkFilename'] = self.block.instantiation.source_position.filename
+
+        if native_class is not None:
+            # TODO: Make sure that this is executed if a native class exists even if there is no native procedure in the block and the block has no native state?
+            data_type = native_class.native_block_data_type
+            if data_type is not None:
+                try:
+                    parsed_native_instance = data_type.create(parameter_values=parameter_values_bystr)
+                except blocks.ProgramError as e:
+                    raise
+                except Exception as e:
+                    raise blocks.InternalCompilerError(block.instantiation, e, msg=f'Error while parsing parameters: {e}')
+        self.static_context = blocks.StaticBlockContext(parameter_values=parameter_values_bystr, parsed_native_instance=parsed_native_instance)
+
+    @property
+    def path(self):
+        if self.is_singleton:
+            return (self.block_type,)
+
+        if self.parent_instance is None:
+            base_path = ()
+        else:
+            base_path = self.parent_instance.path
+        return base_path + (self.block,)