dendrotweaks 0.3.1__py3-none-any.whl

dendrotweaks/membrane/io/ast.py

@@ -0,0 +1,201 @@
+import pprint
+from typing import List
+
+ALLOWED_INDEPENDENT_VARS = ['cai', 'v']
+
+# Assumptions:
+# - Kinetic variables include the state variable name and 
+# the substrings inf or tau (e.g., minf, mtau). Order, case, and additional characters
+# do not matter (e.g., mInf, tau_M are also valid).
+# - The channel is either voltage or calcium dependent, and 
+# the independent variable is either v or cai.
+# - Temperature adjustment coefficient is referred to as tadj and calculated as:
+# tadj = q10^((celsius - temp)/10), where q10 is the temperature coefficient, 
+# temp is the reference temperature, and celsius is the current temperature.
+
+
+
+class AbstracSyntaxTree():
+    """
+    A class to represent the abstract syntax tree of a .mod file.
+
+    Attributes
+    ----------
+    functions : List[Functional]
+        A list of Functional objects representing the FUNCTION blocks in the .mod file.
+    procedures : List[Functional]
+        A list of Functional objects representing the PROCEDURE blocks in the .mod file.
+    """
+
+    def __init__(self, ast_dict: dict):
+        # ast_dict = {k: v[0]
+        #        if len(v) == 1 and k not in ['FUNCTION', 'PROCEDURE'] else v
+        #        for k, v in ast_dict.items()}
+        self.functions = [Functional(func, has_return=True)
+                          for func in ast_dict.get('FUNCTION', [])]
+        self.procedures = [Functional(proc, has_return=False)
+                           for proc in ast_dict.get('PROCEDURE', [])]
+        self._ast = ast_dict
+
+    def __getitem__(self, key):
+        return self._ast[key]
+
+    def __setitem__(self, key, value):
+        self._ast[key] = value
+
+    def __repr__(self):
+        return pprint.pformat(self._ast, sort_dicts=False)
+
+    @property
+    def title(self):
+        return ''.join(self['TITLE']).strip()
+
+    @property
+    def comment(self):
+        return ''.join(self['COMMENT']).strip()
+
+    # NEURON block
+    @property
+    def suffix(self):
+        if self['NEURON'] is not None:
+            return self['NEURON']['suffix']
+
+    @property
+    def ion(self):
+        if self['NEURON'].get('useion'):
+            ions = [ion['ion']
+                    for ion in self['NEURON']['useion'] if ion.get('write', '')]
+            if len(ions) == 1:
+                return ions[0]
+            elif len(ions) == 0:
+                return None
+            else:
+                raise Exception('Multiple ions not supported')
+        else:
+            return None
+
+    # PARAMETER block
+    @property
+    def params(self):
+        """
+        Returns a dictionary of the parameters in the PARAMETER block.
+        """
+        return {param['name']: param['value'] for param in self['PARAMETER']}
+
+    @property
+    def range_params(self):
+        """
+        Returns a dictionary of the range parameters in the PARAMETER block.
+        """
+        return {k:v for k, v in self.params.items()
+                if k in self['NEURON']['range']}
+
+
+    # ASSIGNED block
+    @property
+    def assigned_vars(self):
+        """
+        Returns a list of the assigned variables in the ASSIGNED block.
+        """
+        return [assigned['name'] for assigned in self['ASSIGNED']]
+
+    @property
+    def independent_var_name(self):
+        """
+        Returns the name of the independent variable.
+        Prefers 'cai' over 'v' if both are present.
+        """
+        independent_vars = [var for var in self.assigned_vars 
+                            if any(indep_var in var.lower() 
+                                   for indep_var in ALLOWED_INDEPENDENT_VARS)]
+        if 'cai' in independent_vars:
+            return 'cai'
+        elif 'v' in independent_vars:
+            return 'v'
+        raise Exception('Independent variable not found')
+
+    def is_voltage_dependent(self):
+        """
+        Returns True if the mechanism is voltage dependent.
+        """
+        for var in self.assigned_vars:
+            if 'v' in var.lower():
+                return True
+        return False
+
+    def is_ca_dependent(self):
+        """
+        Returns True if the mechanism is calcium dependent.
+        """
+        for var in self.assigned_vars:
+            if 'cai' in var.lower():
+                return True
+        return False
+
+    # STATE block
+    @property
+    def state_vars(self):
+        """
+        Returns a dictionary of the state variables in the STATE block.
+        """
+        return self['STATE']
+
+
+class Functional():
+    """
+    A class to represent abstract syntax tree of a
+    FUNCTION or PROCEDURE block in a .mod file.
+
+    Attributes
+    ----------
+    has_return : bool
+        Whether the block has a return statement (is a FUNCTION block) 
+        or not (is a PROCEDURE block).
+    """
+
+    def __init__(self, func_ast, has_return=True):
+        self._ast = func_ast
+        self.has_return = has_return
+
+    def __getitem__(self, key):
+        return self._ast[key]
+
+    def get(self, key, default=None):
+        return self._ast.get(key, default)
+
+    def __setitem__(self, key, value):
+        self._ast[key] = value
+
+    def __repr__(self):
+        return pprint.pformat(self._ast, sort_dicts=False)
+
+    # Signature\
+    @property
+    def name(self):
+        return self['signature']['name']
+
+    @name.setter
+    def name(self, value):
+        self['signature']['name'] = value
+
+    @property
+    def params(self):
+        return [param['name'] for param in self['signature'].get('params', [])]
+
+    # Locals
+    @property
+    def local_vars(self):
+        local_vars = []
+        if self.has_return:
+            local_vars.append(self['signature']['name'])
+        local_vars.extend([arg['name'] for arg in self['signature'].get('args', [])])
+        local_vars.extend(self.get('locals', []))
+        return local_vars
+
+    @property
+    def signature(self):
+        return self['signature']
+
+    @property
+    def statements(self):
+        return self['statements']

dendrotweaks/membrane/io/code_generators.py

@@ -0,0 +1,312 @@
+import re
+import os
+from jinja2 import Template
+
+from abc import ABC, abstractmethod
+from jinja2 import Environment, FileSystemLoader
+from dendrotweaks.utils import write_file
+
+# Configure the Jinja2 environment
+# env = Environment(
+#     loader=FileSystemLoader('static/data/templates'),  # Load templates from the 'templates' directory
+#     trim_blocks=False,                      # Trim newlines after Jinja blocks
+#     lstrip_blocks=False,                     # Strip leading whitespace from Jinja blocks
+# )
+
+EQUILIBRIUM_POTENTIALS = {
+    'na': 60,
+    'k': -80,
+    'ca': 140
+}
+
+class CodeGenerator(ABC):
+
+    @abstractmethod
+    def generate(self, ast, path_to_template):
+        pass
+
+    def write_file(self, path_to_file):
+        write_file(self.content, path_to_file)
+
+
+class PythonCodeGenerator(CodeGenerator):
+    """ A class to generate Python code from an AST using a Jinja2 template. """
+
+    def __init__(self):
+        self.content = None
+
+    # MAIN METHOD
+
+    def generate(self, ast, path_to_template):
+        """
+        Generate a Python class from the AST using a Jinja2 template.
+
+        Parameters
+        ----------
+        ast : dict
+            The AST representation of the channel
+        path_to_template : str
+            The path to the Jinja2 template file
+
+        Returns
+        -------
+        str
+            The Python code generated from the AST
+        """
+
+        # Read the template file
+        with open(path_to_template, 'r') as file:
+            template_string = file.read()
+
+        # # Create a Jinja2 template from the string
+        template = Template(template_string)
+        # template = env.get_template(self.path_to_template)
+
+        # Define the variables for the template
+        variables = {
+            'title': ast.title,
+            # 'comment': ast.comment,
+            'class_name': ast.suffix,
+            'suffix': ast.suffix,
+            'ion': ast.ion,
+            'independent_var_name': ast.independent_var_name,
+            'channel_params': ast.params,
+            'range_params': ast.range_params,
+            'state_vars': ast.state_vars,
+            'functions': self._generate_functions(ast),
+            'procedures': self._generate_procedures(ast),
+            'procedure_calls': self._generate_procedure_calls(ast),
+            'E_ion': EQUILIBRIUM_POTENTIALS.get(ast.ion, None)
+        }
+
+        # Render the template with the variables
+        content = template.render(variables)
+
+        if re.search(r'\bjnp\b', template_string):
+            content = content.replace('np', 'jnp')
+
+        self.content = content
+            
+
+    # HELPER METHODS
+
+    def _generate_functions(self, ast, indent=8):
+        functions = []
+
+        for function in ast.functions:
+            # Generate the signature
+            signature_str = self._generate_signature(function.signature)
+
+            # Generate the body
+            body_str = self._generate_body(function.statements)
+            for name in [function.name for function in ast.functions if function != function]:
+                body_str = re.sub(r'\b' + re.escape(name) + r'\b', f"self.{name}", body_str)
+            body_str = re.sub(r'\b' + re.escape('tadj') + r'\b', f"self.tadj", body_str)
+            body_str = re.sub(r'\b' + re.escape('celsius') + r'\b', f"self.temperature", body_str)
+            body_str += f"return {function.name}"
+            body_str = '\n'.join(' ' * indent + line
+                                 for line in body_str.splitlines())
+
+            # Find the parameters that are used in the body
+            params = [param for param in ast.params 
+                      if param not in function.local_vars 
+                      and param not in function.params
+                      and re.search(r'\b' + re.escape(param) + r'\b', body_str)]
+
+            functions.append({
+                'signature': signature_str,
+                'params': params,
+                'body': body_str.strip()
+            })
+        
+        return functions
+
+    def _generate_procedures(self, ast, indent=8):
+
+        if len(ast.procedures) != 1:
+            raise ValueError("Only one procedure is supported")
+        ast.procedures[0].name = 'compute_kinetic_variables'
+
+        procedures = []
+
+        for procedure in ast.procedures:
+            # Generate the signature
+            signature_str = self._generate_signature(procedure.signature, 
+                                                     is_method=True,
+                                                     extra_params=['celsius'])
+
+            # Generate the body
+            body_str = self._generate_body(procedure.statements)
+            for name in [function.name for function in ast.functions]:
+                body_str = re.sub(r'\b' + re.escape(name) + r'\b', f"self.{name}", body_str)
+            body_str = re.sub(r'\b' + re.escape('tadj') + r'\b', f"self.tadj", body_str)
+            body_str = re.sub(r'\b' + re.escape('celsius') + r'\b', f"self.temperature", body_str)
+            body_str += 'return ' + ', '.join([f"{state_var}Inf, {state_var}Tau"
+                                              for state_var in ast.state_vars])
+            body_str = '\n'.join(' ' * indent + line
+                                    for line in body_str.splitlines())
+
+            # Find the parameters that are used in the body
+            params = [param for param in ast.params 
+                      if param not in procedure.local_vars 
+                      and re.search(r'\b' + re.escape(param) + r'\b', body_str)]
+
+            procedures.append({
+                'signature': signature_str,
+                'params': params,
+                'body': body_str.strip()
+            })
+        
+        return procedures
+
+    def _generate_signature(self, signature, is_method=True, extra_params=None):
+        """
+        Generate the signature string for a function using a Jinja2 template.
+        The function AST representation is used to retrieve the function name
+        and parameters:
+        >>> def f_name(self, arg1, arg2, ...):
+
+        Parameters
+        ----------
+        signature : dict
+            The function signature as an AST dictionary
+        is_method : bool
+            Whether the function is a class method or not
+        """
+        signature_template = (
+        "def {{ name }}({% if params %}{{ params | join(', ') }}{% endif %}):"
+        )
+        template = Template(signature_template)
+        name = signature['name']
+        params = [param['name'] for param in signature.get('params', [])]
+        if is_method:
+            params = ['self'] + params
+
+        return template.render(name=name, params=params)
+
+    def _generate_body(self, statements, indent=12, skip_vars=['tadj']):
+        python_code = ""
+        # Add statements
+        for statement in statements:
+            # If the statement is an if-else statement
+            if statement.get('condition', False):
+                python_code += self._generate_conditionals(statement)
+            else:
+                if statement['assigned_var'] in skip_vars:
+                    continue
+                python_code += (f"{statement['assigned_var']} = {statement['expression']}\n")
+        
+        return python_code
+
+    def _generate_conditionals(self, statement):
+        """
+        Generate the conditional statement for an if-else block using a Jinja2 template.
+        """
+        condition = statement['condition']
+        if_statements = statement['if_statements']
+        else_statements = statement.get('else_statements', [])
+        else_statements = {statement['assigned_var']: statement['expression'] for statement in else_statements}
+        
+        conditional_code = ""
+        for if_statement in statement['if_statements']:
+            # Default to variable name if not in else_expressions
+            else_statement = else_statements.get(
+                if_statement['assigned_var'],
+                if_statement["assigned_var"]
+            )
+
+            # Use a Jinja2 template to generate the conditional code
+            conditional_template = (
+            "conditions = [{{ condition }}, ~({{ condition }})]"
+            "\nchoices = [{{ if_statement }}, {{ else_statement }}]"
+            "\n{{ assigned_var }} = np.select(conditions, choices)"
+            )
+            template = Template(conditional_template)
+            conditional_code += template.render(
+                condition=condition,
+                if_statement=if_statement['expression'],
+                else_statement=else_statement,
+                assigned_var=if_statement['assigned_var']
+            )
+            conditional_code += "\n"  # Add a newline between blocks
+
+        return conditional_code
+    
+    def _generate_procedure_calls(self, ast):
+        
+        for procedure in ast.procedures:
+
+            name = procedure.signature['name']
+            params = [param['name'] for param in procedure.signature.get('params', [])]
+            state_vars = list(ast.state_vars.keys())
+
+            procedure_call_template = """{%- for state_var in state_vars -%}
+            {{ state_var }}Inf, {{ state_var }}Tau{% if not loop.last %}, {% endif -%}
+            {% endfor %} = self.{{ name }}({% if params %}{{ params | join(', ') }}{% endif %})
+            """
+            template = Template(procedure_call_template.strip())
+
+            return template.render(
+                name=name,
+                params=params,
+                state_vars=state_vars
+            )
+
+
+
+class NMODLCodeGenerator(CodeGenerator):
+    """ A class to generate NMODL code from a StandardIonChannel"""
+
+    def __init__(self):
+        self.content = None
+
+    def generate(self, channel, 
+                path_to_template: str) -> None:
+        """ 
+        Generate NMODL code for a standardized ion channel 
+        using a Jinja2 template.
+
+        Parameters
+        ----------
+        channel : StandardIonChannel
+            The standardized ion channel.
+        path_to_template : str
+            The path to the Jinja2 template file.
+        """
+        
+        # Read the template file
+        with open(path_to_template, 'r') as file:
+            template_string = file.read()
+
+        # Create a Jinja2 template from the string
+        template = Template(template_string)
+
+        def get_unit(param):
+            if param.startswith('vhalf_'): return 'mV'
+            elif param.startswith('sigma_'): return 'mV'
+            elif param.startswith('k_'): return '1/ms'
+            elif param.startswith('delta_'): return '1'
+            elif param.startswith('tau0_'): return 'ms'
+            elif param.startswith('temp'): return 'degC'
+            elif param.startswith('q10'): return '1'
+            elif param.startswith('gbar'): return 'S/cm2'
+            else: return '1'
+
+        # Define the variables for the template
+        variables = {
+            'suffix': channel.name,
+            'ion': channel.ion,
+            'range_params': [
+                (param, channel.params[param], get_unit(param))
+                for param in channel.params
+            ],
+            'state_vars': {
+                var: params['power'] for var, params in channel._state_powers.items()
+            },
+        }
+
+        # Render the template with the variables
+        content = template.render(variables)
+
+        self.content = content
+        return content

dendrotweaks/membrane/io/converter.py

@@ -0,0 +1,108 @@
+from dendrotweaks.membrane.io.reader import MODFileReader
+from dendrotweaks.membrane.io.parser import MODFileParser
+from dendrotweaks.membrane.io.code_generators import PythonCodeGenerator
+
+class MODFileConverter():
+    """
+    Converts a MOD file to a Python file.
+
+    Attributes
+    ----------
+    reader : MODFileReader
+        The MOD file reader.
+    parser : MODFileParser
+        The MOD file parser.
+    generator : PythonCodeGenerator
+        The Python code generator.
+    """
+
+    def __init__(self):
+        self.reader = MODFileReader()
+        self.parser = MODFileParser()
+        self.generator = PythonCodeGenerator()
+
+    @property
+    def mod_content(self):
+        """
+        The content of the MOD file.
+        """
+        return self.reader.content
+
+    @property
+    def blocks(self):
+        """
+        The blocks of the MOD file corresponding to the 
+        NMODL blocks e.g. NEURON, PARAMETER, ASSIGNED, etc.
+        """
+        return self.reader.blocks
+
+    @property
+    def ast(self):
+        """
+        The abstract syntax tree of the MOD file.
+        """
+        return self.parser.ast
+
+    @property
+    def python_content(self):
+        """
+        The content of the generated Python file.
+        """
+        return self.code_generator.content
+        
+    # def convert(self, path_to_mod, path_to_python, path_to_template):
+    #     """ Converts a mod file to a python file.
+
+    #     Parameters
+    #     ----------
+    #     path_to_mod : str
+    #         The path to the mod file.
+    #     path_to_python : str
+    #         The path to the python file.
+    #     path_to_template : str
+    #         The path to the template file.
+    #     """
+
+    #     self.read_file(path_to_mod) # generates self.mod_content
+    #     self.preprocess() # generates self.blocks
+    #     self.parse() # generates self.ast
+    #     self.generate_python(path_to_template) # generates self.python_content
+    #     self.write_file(path_to_python) # writes self.python_content to path_to_python
+
+    def convert(self, path_to_mod_file: str, 
+                path_to_python_file: str, 
+                path_to_python_template: str, 
+                path_to_json_file:str = None,
+                verbose: bool = False) -> None:
+        """ Converts a MOD file to a Python file.
+
+        Parameters
+        ----------
+        path_to_mod : str
+            The path to the original MOD file.
+        path_to_python : str
+            The path to the output Python file.
+        path_to_template : str
+            The path to the jinja2 template file.
+        path_to_json : str, optional
+            The path to the json file to write the AST.
+        verbose : bool, optional
+            Whether to print the progress of the conversion.
+        """
+
+        if verbose: print(f"READING")
+        self.reader.read_file(path_to_mod_file)
+        self.reader.preprocess()
+        blocks = self.reader.get_blocks(verbose)
+        
+        if verbose: print(f"\nPARSING")
+        self.parser.parse(blocks, verbose)
+        self.parser.postprocess()
+        ast = self.parser.get_ast()
+        
+        if path_to_json_file:
+            self.parser.write_file(path_to_json_file)
+        
+        if verbose: print(f"\nGENERATING")
+        self.generator.generate(ast, path_to_python_template)
+        self.generator.write_file(path_to_python_file)