dendrotweaks 0.3.1__py3-none-any.whl

dendrotweaks/membrane/io/factories.py

@@ -0,0 +1,144 @@
+import os
+import sys
+from typing import List, Tuple
+
+
+from dendrotweaks.membrane.io.converter import MODFileConverter
+from dendrotweaks.membrane.io.code_generators import NMODLCodeGenerator
+from dendrotweaks.membrane.mechanisms import Mechanism, IonChannel, StandardIonChannel
+
+
+def create_channel(path_to_mod_file: str,
+                   path_to_python_file: str,
+                   path_to_python_template: str,
+                   verbose: bool = False) -> IonChannel:
+    """
+    Creates an ion channel from a .mod file.
+
+    Parameters
+    ----------
+    path_to_mod_file : str
+        The full path to the .mod file containing the channel mechanism.
+    path_to_python_file : str
+        The path to the output Python file to be generated.
+    path_to_python_template : str
+        The path to the jinja2 template file for the Python file.
+    verbose : bool, optional
+        Whether to print verbose output.
+
+    Returns
+    -------
+    IonChannel
+        The instantiated ion channel.
+    """
+    # Convert mod to python
+    converter = MODFileConverter()
+    converter.convert(path_to_mod_file, 
+                      path_to_python_file, 
+                      path_to_python_template,
+                      verbose=verbose)
+
+    # Import and instantiate the channel
+    class_name = os.path.basename(path_to_python_file).replace('.py', '')
+    module_name = class_name
+    package_path = os.path.dirname(path_to_python_file)
+    
+    if package_path not in sys.path:
+        sys.path.append(package_path)
+    
+    # Dynamic import
+    from importlib import import_module
+    module = import_module(module_name)
+    ChannelClass = getattr(module, class_name)
+    
+    return ChannelClass()
+
+
+def standardize_channel(channel: IonChannel, 
+                        path_to_mod_template: str = None,
+                        path_to_standard_mod_file: str = None) -> StandardIonChannel:
+    """
+    Standardize a channel and optionally generate a MOD file.
+
+    Parameters
+    ----------
+    channel : IonChannel
+        The channel to standardize.
+    path_to_mod_template : str, optional
+        The path to the jinja2 template file for the standard MOD file.
+    path_to_standard_mod_file : str, optional
+        The path to save the standardized MOD file.
+
+    Returns
+    -------
+    StandardIonChannel
+        A standardized version of the input channel.
+
+    Note
+    ----
+    Temperature-dependence is taken into account by performing
+    a fit to the data at the temperature specified in the parameters
+    of the original channel model (the `temp` parameter). If no
+    temperature is specified, the default temperature of 23 degrees
+    Celsius is used.
+    """
+    standard_channel = StandardIonChannel(name=f"std{channel.name}", 
+                                          state_powers=channel._state_powers, 
+                                          ion=channel.ion)
+
+    standard_channel.params.update({'q10': channel.params.get('q10'),
+                                    'temp': channel.params.get('temp')})
+
+    fit_temperature = channel.params.get('temp') or 23
+
+    standard_channel.set_tadj(fit_temperature)
+    # Fit the standard channel to the data
+    data = channel.get_data(temperature=fit_temperature)
+    standard_channel.fit(data)
+
+    # Optionally generate a MOD file
+    
+    generator = NMODLCodeGenerator()
+    content = generator.generate(standard_channel, path_to_mod_template)
+    generator.write_file(path_to_standard_mod_file)
+
+    return standard_channel
+
+
+def create_standard_channel(path_to_mod_file: str,
+                           path_to_python_file: str,
+                           path_to_python_template: str,
+                           path_to_mod_template: str,
+                           path_to_standard_mod_file: str,
+                           verbose: bool = False) -> StandardIonChannel:
+    """
+    Creates a standardized channel and fits it to the data of the unstandardized channel.
+
+    Parameters
+    ----------
+    path_to_mod_file : str
+        The path to the original MOD file for an unstandardized channel.
+    path_to_python_file : str
+        The path to the output Python file to be generated.
+    path_to_python_template : str
+        The path to the jinja2 template file for the Python file.
+    path_to_mod_template : str
+        The path to the jinja2 template file for the standard MOD file.
+    path_to_standard_mod_file : str
+        The path to the output standardized MOD file.
+    verbose : bool, optional
+        Whether to print verbose output.
+
+    Returns
+    -------
+    StandardIonChannel
+        The standardized ion channel.
+    """
+    # First create the regular channel
+    channel = create_channel(path_to_mod_file, 
+                            path_to_python_file, 
+                            path_to_python_template,
+                            verbose=verbose)
+    
+    # Then standardize it
+    return standardize_channel(channel, path_to_mod_template, path_to_standard_mod_file)

dendrotweaks/membrane/io/grammar.py

@@ -0,0 +1,417 @@
+import pyparsing as pp
+
+pp.ParserElement.enablePackrat()
+
+from pyparsing import (alphas, alphanums, nums)
+from pyparsing import (Char, Word, Empty, Literal, Regex, Keyword)
+from pyparsing import (infix_notation, opAssoc)
+
+from pyparsing import (Group, Combine, Dict, Suppress, delimitedList, Optional)
+from pyparsing import (ZeroOrMore, OneOrMore, oneOf)
+from pyparsing import Forward
+from pyparsing import (restOfLine, SkipTo)
+from pyparsing import pyparsing_common
+from pyparsing import LineEnd
+from pyparsing import infixNotation, opAssoc, And
+from pyparsing import NotAny
+
+# Symbols
+LBRACE, RBRACE, LPAREN, RPAREN, EQUAL, COLON = map(Suppress, "{}()=:")
+
+# Keywords
+
+## Block keywords
+TITLE = Suppress(Keyword('TITLE', caseless=False))
+COMMENT = Suppress(Keyword('COMMENT', caseless=False))
+ENDCOMMENT = Suppress(Keyword('ENDCOMMENT', caseless=False))
+NEURON = Suppress(Keyword('NEURON', caseless=False))
+UNITS = Suppress(Keyword('UNITS', caseless=False))
+PARAMETER = Suppress(Keyword('PARAMETER', caseless=False))
+ASSIGNED = Suppress(Keyword('ASSIGNED', caseless=False))
+STATE = Suppress(Keyword('STATE', caseless=False))
+BREAKPOINT = Suppress(Keyword('BREAKPOINT', caseless=False))
+INITIAL = Suppress(Keyword('INITIAL', caseless=False))
+DERIVATIVE = Suppress(Keyword('DERIVATIVE', caseless=False))
+FUNCTION = Suppress(Keyword('FUNCTION', caseless=False))
+PROCEDURE = Suppress(Keyword('PROCEDURE', caseless=False))
+INDEPENDENT = Suppress(Keyword('INDEPENDENT', caseless=False))
+FROM = Suppress(Keyword('FROM', caseless=False))
+TO = Suppress(Keyword('TO', caseless=False))
+KINETIC = Suppress(Keyword('KINETIC', caseless=False))
+STEADYSTATE = Suppress(Keyword('STEADYSTATE', caseless=False))
+
+block_to_keep = TITLE | COMMENT | NEURON | UNITS | PARAMETER | ASSIGNED | STATE | BREAKPOINT | INITIAL | DERIVATIVE | FUNCTION | PROCEDURE
+
+## Misc keywords
+VERBATIM = Suppress(Keyword('VERBATIM', caseless=False))
+ENDVERBATIM = Suppress(Keyword('ENDVERBATIM', caseless=False))
+
+
+
+# TITLE
+
+title = Combine(TITLE + restOfLine('block'))
+
+comment = Combine(COLON + restOfLine)("comment")
+
+
+comment_block = Combine(COMMENT + SkipTo(ENDCOMMENT) + ENDCOMMENT)('block')
+
+# VERBATIM
+verbatim = VERBATIM + SkipTo(ENDVERBATIM) + ENDVERBATIM
+
+## Block keywords
+FARADAY = Keyword('FARADAY', caseless=False)
+R = Keyword('R', caseless=False)
+
+number = pyparsing_common.number
+identifier = Word(alphas, alphanums + "_") 
+# unit = Combine(LPAREN + Word(alphas + nums + "/") + RPAREN)
+unit = Combine(LPAREN
+               + ( Combine(Word(alphas + "23") + "/" + Word(alphas + "23"))
+                  | Combine("/" + Word(alphas + "23") + "/" + Word(alphas + "23"))
+                  | Combine("/" + Word(alphas + "23"))
+                  | Combine(Word(nums) + "/" + Word(alphas + "23"))
+                  | Word(alphas + "23"))
+               + RPAREN)
+dimensionless = LPAREN + Literal("1") + RPAREN
+
+faraday_constant = Dict(Group(FARADAY + EQUAL + LPAREN + Suppress(Literal('faraday')) + RPAREN + Optional(unit)))
+gas_constant = Dict(Group(R + EQUAL + LPAREN + Suppress(Literal('k-mole')) + RPAREN + Optional(unit)))
+
+constant = faraday_constant | gas_constant
+
+quantity = And([number + Suppress(unit)])
+
+value_range = Suppress(Literal('<')) + Suppress(number) + Suppress(Literal(',')) + Suppress(number) + Suppress(Literal('>'))
+
+from_to = FROM + number("from") + TO + number("to")
+
+# NEURON block
+
+## Block keywords
+SUFFIX = Suppress(Keyword('SUFFIX', caseless=False))
+NONSPECIFIC_CURRENT = Suppress(Keyword('NONSPECIFIC_CURRENT', caseless=False))
+USEION = Suppress(Keyword('USEION', caseless=False))
+READ = Suppress(Keyword('READ', caseless=False))
+WRITE = Suppress(Keyword('WRITE', caseless=False))
+VALENCE = Suppress(Keyword('VALENCE', caseless=False))
+RANGE = Suppress(Keyword('RANGE', caseless=False))
+GLOBAL = Suppress(Keyword('GLOBAL', caseless=False))
+
+## Block statements
+suffix_stmt = SUFFIX + identifier("suffix")
+nonspecific_current_stmt = NONSPECIFIC_CURRENT + identifier("nonspecific_current")
+useion_stmt = (Group(
+    USEION
+    + identifier('ion')
+    + Group(READ + delimitedList(identifier))("read")
+    + Optional(Group(WRITE + delimitedList(identifier))("write"))
+    + Optional(VALENCE + number("valence"))
+))("useion*")
+range_stmt = Group(RANGE + delimitedList(identifier))("range")
+global_stmt = Group(GLOBAL + delimitedList(identifier))("global")
+
+neuron_stmt = suffix_stmt | nonspecific_current_stmt | useion_stmt | range_stmt | global_stmt
+
+## Block definition
+neuron_block = Group(
+    NEURON
+    + LBRACE
+    + OneOrMore(neuron_stmt)
+    + RBRACE
+)("block")
+
+
+# UNITS block
+
+
+
+## Block statements
+unit_definition = Dict(Group(unit + EQUAL + unit)) | constant
+
+## Block definition
+units_block = Group(
+    UNITS 
+    + LBRACE 
+    + OneOrMore(unit_definition) 
+    + RBRACE
+)("block")
+
+# units_blocks = ZeroOrMore(units_block)("units_block")
+
+# PARAMETER block
+
+## Block statements
+parameter_stmt = Group(
+    identifier('name')
+    + EQUAL 
+    + number('value') 
+    + Optional(unit | dimensionless)('unit') 
+    + Optional(value_range('value_range'))
+)
+
+## Block definition
+parameter_block = Group(
+    PARAMETER 
+    + LBRACE 
+    + OneOrMore(parameter_stmt)
+    + RBRACE
+)("block")
+
+parameter_block = parameter_block.ignore(comment)
+
+
+
+# ASSIGNED block
+
+
+## Block statements
+assigned_stmt = Group(
+    identifier('name')
+    + Optional(unit | dimensionless)('unit') 
+    )
+
+## Block definition
+assigned_block = Group(
+    ASSIGNED 
+    + LBRACE 
+    + OneOrMore(assigned_stmt)
+    + RBRACE
+)("block")
+
+assigned_block = assigned_block.ignore(comment)
+
+
+# STATE block
+
+## Block definition
+state_var = Word(alphas) + Suppress(Optional(unit | dimensionless)) + Suppress(Optional(from_to))
+# state_var = Group(identifier('name') + Optional(unit | dimensionless)('unit') + Optional(comment))
+state_block = Group(
+    STATE 
+    + LBRACE 
+    + OneOrMore(state_var) 
+    + RBRACE
+)('block')
+
+
+
+
+# breakpoint_block = BREAKPOINT + SkipTo(block_to_keep)
+# breakpoint_block = Suppress(breakpoint_block)
+
+# DERIVATIVE block (not used)
+# derivative_block = DERIVATIVE + SkipTo(block_to_keep)
+# derivative_block = Suppress(derivative_block)
+
+# INDEPENDENT block (not used)
+independent_block = INDEPENDENT + SkipTo(block_to_keep)
+independent_block = Suppress(independent_block)
+
+kinetic_block = KINETIC + SkipTo(block_to_keep)
+kinetic_block = Suppress(kinetic_block)
+
+derivative_block = DERIVATIVE + SkipTo(block_to_keep)
+derivative_block = Suppress(kinetic_block)
+
+# Functional blocks
+
+## Signature
+
+param = Group(identifier('name') + Optional(unit('unit') | dimensionless('unit')))
+param_list = delimitedList(param)('params')
+signature = Group(
+    identifier('name') 
+    + LPAREN 
+    + Optional(param_list) 
+    + RPAREN 
+    + Optional(unit)('returned_unit')
+)('signature')
+
+## Local 
+LOCAL = Keyword("LOCAL", caseless=False)
+LOCAL = Suppress(LOCAL)
+local_stmt = LOCAL + delimitedList(identifier)
+
+# Expression
+expr = Forward()
+parenth_expr = LPAREN + expr + RPAREN
+
+## Function call with arguments
+arg = expr | identifier | number
+arg_list = delimitedList(arg)('args')
+func_call_with_args = Group(identifier + LPAREN + Optional(arg_list) + RPAREN)
+def func_call_with_args_action(tokens):
+    function_name = tokens[0][0]
+    function_args = tokens[0][1:]
+    return {function_name: function_args}
+func_call_with_args.setParseAction(func_call_with_args_action)
+
+## Function call with expression
+func_call_with_expr = Group(identifier('name') + LPAREN + expr + RPAREN)
+def func_call_with_expr_action(tokens):
+    function_name = tokens[0][0]
+    function_expr = tokens[0][1]
+    return {function_name: function_expr}
+func_call_with_expr.setParseAction(func_call_with_expr_action)
+
+## Operands
+func_operand = func_call_with_args | func_call_with_expr
+operand = func_operand | quantity | number | identifier # the order is important!
+operand = operand | LPAREN + operand + RPAREN
+
+## Operators
+signop = Literal('-')
+plusop = oneOf('+ -')
+mulop = oneOf('* /')
+orderop = oneOf('< > <= >= ==')
+powop = Literal('^')
+
+# def sign_action(tokens):
+#     tokens = tokens[0]
+#     return {tokens[0]: tokens[1]}
+
+# def op_action(tokens):
+#     tokens = tokens[0]
+#     return {tokens[1]: [tokens[0], tokens[2]]}
+
+def sign_action(tokens):
+    tokens = tokens[0]
+    return {tokens[0]: [tokens[1]]}
+
+def op_action(tokens):
+    tokens = tokens[0]
+    while len(tokens) > 3:
+        tokens = [{tokens[1]: [tokens[0], tokens[2]]}] + tokens[3:]
+    return {tokens[1]: [tokens[0], tokens[2]]}
+
+## Expression
+expr <<= infix_notation(
+ operand,
+ [
+  (signop, 1, opAssoc.RIGHT, sign_action),
+  (powop, 2, opAssoc.RIGHT, op_action),
+  (mulop, 2, opAssoc.LEFT, op_action),
+  (plusop, 2, opAssoc.LEFT, op_action),
+  (orderop, 2, opAssoc.LEFT, op_action),
+ ]
+)
+
+
+# expr = expr | LPAREN + expr + RPAREN
+
+
+## Assignment
+assignment_stmt = Group(
+    identifier('assigned_var')
+    + EQUAL 
+    + expr('expression')
+)
+
+# BREAKPOINT block (not used)
+SOLVE = Suppress(Keyword('SOLVE', caseless=False))
+METHOD = Suppress(Keyword('METHOD', caseless=False))
+STEADYSTATE = Suppress(Keyword('STEADYSTATE', caseless=False))
+
+solve_stmt = Group(
+    SOLVE
+    + identifier("solve")
+    + (METHOD | STEADYSTATE)
+    + identifier("method")
+)("solve_stmt")
+
+breakpoint_block = Group(
+    BREAKPOINT 
+    + LBRACE 
+    + solve_stmt
+    + ZeroOrMore(assignment_stmt)("statements")
+    + RBRACE
+)("block")
+
+initial_stmt = (solve_stmt | assignment_stmt | func_call_with_args )
+
+initial_block = Group(
+    INITIAL
+    + LBRACE
+    # + OneOrMore(func_call_with_args)("func_calls")
+    # + OneOrMore(assignment_stmt)("statements")
+    + OneOrMore(initial_stmt)("statements")
+    + RBRACE
+)("block")
+
+derivative_assignment_stmt = Group(
+    identifier('assigned_var') 
+    + "'"
+    + EQUAL 
+    + expr('expression')
+)
+
+derivative_block = Group(
+    DERIVATIVE
+    + Word(alphas)("name")
+    + LBRACE
+    + OneOrMore(func_call_with_args)("func_calls")
+    + OneOrMore(derivative_assignment_stmt)("statements")
+    + RBRACE
+)("block")
+
+# FUNCTION block
+
+## IF-ELSE statement
+IF = Keyword("if", caseless=False)
+IF = Suppress(IF)
+ELSE = Keyword("else", caseless=False)
+ELSE = Suppress(ELSE)
+
+if_else_stmt = Group(
+    IF + LPAREN + expr('condition') + RPAREN 
+    + LBRACE 
+    + OneOrMore(assignment_stmt)('if_statements')
+    + RBRACE
+    + Optional(ELSE + LBRACE + OneOrMore(assignment_stmt)('else_statements') + RBRACE)
+)
+
+
+# if_else_stmt = if_else_stmt('if_else_statements*')
+# assignment_stmt = assignment_stmt('assignment_statements*')
+
+stmt = (assignment_stmt | if_else_stmt)
+
+## Block definition
+function_block = Group(
+    FUNCTION 
+    + signature('signature') 
+    + LBRACE 
+    + ZeroOrMore(local_stmt)('locals')
+    # + ZeroOrMore(if_else_stmt)('if_else_statements')
+    # + ZeroOrMore(assignment_stmt)('statements')
+    + OneOrMore(stmt)("statements")
+    + RBRACE)("block")
+
+function_blocks = OneOrMore(function_block)("function_blocks")
+
+
+# PROCEDURE block
+
+# stmt = (if_else_stmt('if_else_statements*') | assignment_stmt('statements*'))
+
+
+
+## Block definition
+procedure_block = Group(
+    PROCEDURE 
+    + signature('signature') 
+    + LBRACE 
+    + ZeroOrMore(local_stmt)('locals')
+    # + ZeroOrMore(if_else_stmt)('if_else_statements')
+    # + OneOrMore(assignment_stmt)('statements')
+    + OneOrMore(stmt)('statements')
+    + RBRACE)("block")
+
+procedure_blocks = OneOrMore(procedure_block)("procedure_blocks")
+
+# MOD file
+
+block = kinetic_block | independent_block | breakpoint_block | initial_block | derivative_block | procedure_blocks | function_blocks | title | comment_block | neuron_block | units_block | parameter_block | assigned_block | state_block
+grammar = Group(ZeroOrMore(block))('mod_file')

dendrotweaks/membrane/io/loader.py

@@ -0,0 +1,90 @@
+import os
+import shutil
+import subprocess
+import neuron
+from neuron import h
+
+from pprint import pprint
+
+class MODFileLoader():
+
+    def __init__(self):
+        self._loaded_mechanisms = set()
+        self.verbose = False
+              
+    # LOADING METHODS
+
+    def _get_mechanism_dir(self, path_to_mod_file: str) -> str:
+        """
+        Get the subdirectory for the given mod file.
+
+        Parameters
+        ----------
+        path_to_mod_file : str
+            Path to the .mod file.
+
+        Returns
+        -------
+        str
+            Path to the subdirectory for the mechanism.
+        """
+        mechanism_name = os.path.basename(path_to_mod_file).replace('.mod', '')
+        parent_dir = os.path.dirname(path_to_mod_file)
+        return os.path.join(parent_dir, mechanism_name)
+
+    def load_mechanism(self, path_to_mod_file: str, 
+                       recompile: bool = False) -> None:
+        """
+        Load a mechanism from the specified mod file.
+        Uses the NEURON neuron.load_mechanisms method to make
+        the mechanism available in the hoc interpreter.
+        Creates a temporary directory for the mechanism files
+        to be able to dynamically load mechanisms.
+
+        Parameters
+        ----------
+        path_to_mod_file : str
+            Path to the .mod file.
+        recompile : bool
+            Force recompilation even if already compiled.
+        """
+        mechanism_name = os.path.basename(path_to_mod_file).replace('.mod', '')
+        mechanism_dir = self._get_mechanism_dir(path_to_mod_file)
+        x86_64_dir = os.path.join(mechanism_dir, 'x86_64')
+
+        if self.verbose: print(f"{'=' * 60}\nLoading mechanism {mechanism_name} to NEURON...\n{'=' * 60}")
+
+        if mechanism_name in self._loaded_mechanisms:
+            if self.verbose: print(f'Mechanism "{mechanism_name}" already loaded')
+            return
+
+        if recompile and os.path.exists(mechanism_dir):
+            shutil.rmtree(mechanism_dir)
+
+        if not os.path.exists(x86_64_dir):
+            if self.verbose: print(f'Compiling mechanism "{mechanism_name}"...')
+            os.makedirs(mechanism_dir, exist_ok=True)
+            shutil.copy(path_to_mod_file, mechanism_dir)
+            self._compile_files(mechanism_dir)
+
+        if hasattr(h, mechanism_name):
+            if self.verbose: print(f'Mechanism "{mechanism_name}" already exists in hoc')
+        else:
+            try:
+                neuron.load_mechanisms(mechanism_dir)
+            except Exception as e:
+                print(f"Failed to load mechanism {mechanism_name}: {e}")
+                return
+        self._loaded_mechanisms.add(mechanism_name)
+        if self.verbose: print(f'Loaded mechanism "{mechanism_name}"')
+
+    # HELPER METHODS
+
+    
+    def _compile_files(self, path: str) -> None:
+        """Compile the MOD files in the specified directory."""
+        try:
+            subprocess.run(["nrnivmodl"], cwd=path, check=True)
+        except subprocess.CalledProcessError as e:
+            print(f"Compilation failed: {e}")
+