gnps 0.0.0__tar.gz

gnps-0.0.0/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.1
+Name: gnps
+Version: 0.0.0
+Summary: Generalized Numerical P Systems simulator package
+Author-Email: Sergey Verlan <dont-spam-me@no.spam>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.10
+Requires-Dist: lark~=1.1
+Requires-Dist: PyYAML~=6.0
+Description-Content-Type: text/markdown
+
+# GNPS project
+
+The *GNPS* project (Generalized Numerical P Systems) aims to create a 
+library for simulation of different variants of Numerical P Systems (NPS).
+
+It contains:
+
+* GNPS core (the core classes for NPS simulation)
+* GNPS parser (parsers for different inputs)
+* GNPS generator (generates outputs, i.e. Verilog, Amaranth and Lustre) *work in progress.*
+* Utils (like the main runner)
+
+## Input Files
+
+- **System description**: YAML file describing the GNPS system (required as the first argument).
+- **Input file**: Optional CSV file, each row representing input variable values for a simulation step. The header must match the input variable names defined in the YAML.
+- **Output file**: Optional CSV file, each row representing output variable values for each step.
+
+## Command Line Options
+
+Run the simulator with:
+
+    python -m gnps <gnps_file.yaml> [input.csv] [output.csv] [options]
+
+Options:
+- `-c`, `--compute_mode`   Run in continuous compute mode (no input variables allowed)
+- `-s`, `--steps N`        Number of steps to run (default: 1)
+- `--csv`                  Output in CSV format in continuous compute mode
+
+- `gnps_file` (YAML): Required. GNPS system description.
+- `input` (CSV): Optional. Input values per step (default: stdin).
+- `output` (CSV): Optional. Output values per step (default: stdout).
+
+## Modes
+
+- **IO mode (default)**: Reads input variables from CSV for each step, writes output variables for each step.
+- **Continuous compute mode**: Runs for a set number of steps without input variables, outputs results at each step (CSV or text).
+
+## Example Input YAML
+
+Below is an example of a GNPS system description in YAML format (from `test_math_functions.yaml`):
+
+```yaml
+description: "A test system"
+
+cells:
+  - id: 1
+    contents:
+      - x = 0, y = 0, E = 0, z = 0, u = 1
+      # Comments can be added like this
+    # input variables should be empty for continuous compute mode
+    input: [u] 
+    output: [x,y,z]
+
+rules:
+  - E > x | x + 3 -> x  # guarded rule
+  - E + 1 -> E         # unguarded rule
+  - 0*z + x + y -> z
+  - (E > u || E > x || E > y) | u + x + y -> y                                   # step will be reset to 0
+```
+
+
+For more details, see the CHANGELOG.md and documentation in the docs/ folder.

gnps-0.0.0/README.md

@@ -0,0 +1,63 @@
+# GNPS project
+
+The *GNPS* project (Generalized Numerical P Systems) aims to create a 
+library for simulation of different variants of Numerical P Systems (NPS).
+
+It contains:
+
+* GNPS core (the core classes for NPS simulation)
+* GNPS parser (parsers for different inputs)
+* GNPS generator (generates outputs, i.e. Verilog, Amaranth and Lustre) *work in progress.*
+* Utils (like the main runner)
+
+## Input Files
+
+- **System description**: YAML file describing the GNPS system (required as the first argument).
+- **Input file**: Optional CSV file, each row representing input variable values for a simulation step. The header must match the input variable names defined in the YAML.
+- **Output file**: Optional CSV file, each row representing output variable values for each step.
+
+## Command Line Options
+
+Run the simulator with:
+
+    python -m gnps <gnps_file.yaml> [input.csv] [output.csv] [options]
+
+Options:
+- `-c`, `--compute_mode`   Run in continuous compute mode (no input variables allowed)
+- `-s`, `--steps N`        Number of steps to run (default: 1)
+- `--csv`                  Output in CSV format in continuous compute mode
+
+- `gnps_file` (YAML): Required. GNPS system description.
+- `input` (CSV): Optional. Input values per step (default: stdin).
+- `output` (CSV): Optional. Output values per step (default: stdout).
+
+## Modes
+
+- **IO mode (default)**: Reads input variables from CSV for each step, writes output variables for each step.
+- **Continuous compute mode**: Runs for a set number of steps without input variables, outputs results at each step (CSV or text).
+
+## Example Input YAML
+
+Below is an example of a GNPS system description in YAML format (from `test_math_functions.yaml`):
+
+```yaml
+description: "A test system"
+
+cells:
+  - id: 1
+    contents:
+      - x = 0, y = 0, E = 0, z = 0, u = 1
+      # Comments can be added like this
+    # input variables should be empty for continuous compute mode
+    input: [u] 
+    output: [x,y,z]
+
+rules:
+  - E > x | x + 3 -> x  # guarded rule
+  - E + 1 -> E         # unguarded rule
+  - 0*z + x + y -> z
+  - (E > u || E > x || E > y) | u + x + y -> y                                   # step will be reset to 0
+```
+
+
+For more details, see the CHANGELOG.md and documentation in the docs/ folder.

gnps-0.0.0/pyproject.toml

@@ -0,0 +1,104 @@
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[project]
+name = "gnps"
+dynamic = []
+authors = [
+    { name = "Sergey Verlan", email = "dont-spam-me@no.spam" },
+]
+description = "Generalized Numerical P Systems simulator package"
+readme = "README.md"
+dependencies = [
+    "lark~=1.1",
+    "PyYAML~=6.0",
+]
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Development Status :: 4 - Beta",
+]
+version = "0.0.0"
+
+[project.license]
+text = "MIT"
+
+[project.scripts]
+gnps = "gnps.__main__:main"
+gnps-transformer = "gnps.cli_transform:main"
+
+[tool.pdm]
+autoexport = [
+    { filename = "requirements.txt", without-hashes = true },
+]
+
+[tool.pdm.version]
+source = "scm"
+fallback_version = "0.0.0"
+tag_filter = "v*"
+tag_regex = "^v(.*)$"
+write_to = "gnps/_version.py"
+write_template = "__version__ = '{}'"
+
+[tool.pdm.scripts]
+test = "pytest --cov=gnps --cov-report=xml --cov-report=term-missing"
+
+[tool.coverage.run]
+branch = true
+source = [
+    "src/gnps/",
+    "tests/",
+]
+omit = [
+    "*/__main__.py",
+    "*/_version.py",
+    "venv/*",
+    "cli.py",
+]
+
+[tool.coverage.report]
+show_missing = true
+skip_covered = true
+omit = [
+    "*/__main__.py",
+    "*/_version.py",
+    "cli.py",
+    "venv/*",
+]
+exclude_also = [
+    "if __name__ == .__main__.:",
+]
+exclude_lines = [
+    "pragma: no cover",
+    "if __name__ == .__main__.:",
+    "def __repr__",
+    "def __str__",
+    "raise NotImplementedError",
+]
+ignore_errors = true
+
+[tool.coverage.html]
+directory = "coverage_html_report"
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+pythonpath = [
+    "src/",
+]
+testpaths = [
+    "tests/unit_tests/",
+    "tests/functional_tests/",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=7.4.3",
+    "sphinx>=7.2.6",
+    "pytest-cov>=7.0.0",
+    "sphinx-rtd-theme>=3.0.2",
+]

gnps-0.0.0/src/gnps/__init__.py

@@ -0,0 +1,3 @@
+from .cell import Cell
+from .rule import Rule
+from .system import GnpsSystem

gnps-0.0.0/src/gnps/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == '__main__':
+    main()

gnps-0.0.0/src/gnps/_version.py

@@ -0,0 +1 @@
+__version__ = '0.0.0'

gnps-0.0.0/src/gnps/cell.py

@@ -0,0 +1,26 @@
+from .parser.ast.variable import Variable
+
+
+class Cell:
+    """
+      The class representing a cell.
+
+      :param id: The id of the cell.
+      :type id: int
+
+      :param contents: The contents of the cell. It is a dictionary of variables.
+      :type contents: dict[str, Variable]
+    """
+    id: int
+    contents: dict[str, Variable]
+
+    def __init__(self, cell_id: int, contents: dict[str, Variable]):
+        """
+        Initialize a cell.
+        :param cell_id: the cell id
+        :type cell_id: int
+        :param contents: the contents of the cell (a dictionary of variables)
+        :type contents: dict[str, Variable]
+        """
+        self.id = cell_id
+        self.contents = contents

gnps-0.0.0/src/gnps/cli.py

@@ -0,0 +1,89 @@
+import argparse
+import csv
+import sys
+from typing import Dict
+
+from lark import Tree
+
+from gnps import Cell
+from gnps.parser.ast import Variable
+from gnps.parser.ast.value import FloatValue
+from gnps.system import GnpsSystem
+from gnps.parser import parse_condition, parse_expression, parse_rule, parse_variable_assignment
+
+from gnps._version import __version__
+
+def main():
+    parser = argparse.ArgumentParser(description=f"GNPS simulator v{__version__}", prog='gnps')
+    parser.add_argument('gnps_file', type=argparse.FileType('r'),
+                        help='The file containing the description of the GNPS system')
+    parser.add_argument('input', type=argparse.FileType('r'), nargs='?', default=sys.stdin,
+                        help='Input (CSV) file giving stimulus for each step (default: stdin)')
+    parser.add_argument('output', type=argparse.FileType('w'), nargs='?', default=sys.stdout,
+                        help='Output (CSV) file giving the results of each step (default: stdout)')
+    parser.add_argument('-c', '--compute_mode', action='store_true',
+                        help='Run in continuous compute mode (default: False)')
+    parser.add_argument('-s', '--steps', type=int, default=1,
+                        help='Number of steps to run (default: 1)')
+    parser.add_argument('--csv', action='store_true',
+                        help='Output in CSV format when in continuous compute mode')
+    args = parser.parse_args()
+
+    gnps = GnpsSystem.from_yaml(args.gnps_file.name)
+
+    if args.compute_mode:
+        if len(gnps.input_variables) > 0:
+            raise ValueError("Cannot run in continuous compute mode with input variables")
+        if args.csv:
+            # CSV output mode
+            args.output.reconfigure(newline='')
+            result = {name: str(variable.value) for name, variable in gnps.output_variables.items()}
+            fieldnames = ['step'] + list(result.keys())
+            writer = csv.DictWriter(args.output, fieldnames=fieldnames)
+            writer.writeheader()
+            # Write initial state (step 0) with only output variables
+            row = {'step': 0}
+            row.update(result)
+            writer.writerow(row)
+            for i in range(args.steps):
+                gnps.step()
+                result = {name: str(variable.value) for name, variable in gnps.output_variables.items()}
+                row = {'step': i+1}
+                row.update(result)
+                writer.writerow(row)
+        else:
+            print(f"Running in continuous compute mode for {args.steps} steps")
+            result = {name: str(variable.value) for name, variable in gnps.output_variables.items()}
+            print(f"Step: 0: {result}")
+            for i in range(args.steps):
+                gnps.step()
+                result = {name: str(variable.value) for name, variable in gnps.output_variables.items()}
+                print(f"Step: {i+1}: {result}")
+    else:  # IO mode
+
+        args.output.reconfigure(newline='')
+        args.input.reconfigure(newline='')
+
+        reader = csv.DictReader(args.input)
+        writer = None
+
+        for row in reader:
+
+            for input_var_name, input_var_value in row.items():
+                var = gnps.get_variable(input_var_name)
+                if var is None or input_var_name not in gnps.input_variables.keys():
+                    raise ValueError(f"Unknown input variable {input_var_name}")
+                var.value = FloatValue(input_var_value)
+
+            gnps.step()
+
+            result = {name: variable.value for name, variable in gnps.output_variables.items()}
+
+            if writer is None:
+                writer = csv.DictWriter(args.output, fieldnames=result.keys())
+                writer.writeheader()
+            writer.writerow(result)
+
+
+if __name__ == '__main__':
+    main()

gnps-0.0.0/src/gnps/cli_transform.py

@@ -0,0 +1,134 @@
+"""CLI tool for transforming GNPS systems to various output formats."""
+
+import argparse
+import sys
+from pathlib import Path
+from typing import Dict, Type
+
+from gnps.system import GnpsSystem
+from gnps.transformers import BaseTransformer, PythonTransformer
+from gnps._version import __version__
+
+
+# Registry of available transformers
+TRANSFORMERS: Dict[str, Type[BaseTransformer]] = {
+    'python': PythonTransformer,
+}
+
+
+def get_transformer(transform_type: str) -> BaseTransformer:
+    """Get a transformer instance by type name.
+
+    Args:
+        transform_type: The type of transformer to create
+
+    Returns:
+        Transformer instance
+
+    Raises:
+        ValueError: If transform_type is not supported
+    """
+    if transform_type not in TRANSFORMERS:
+        available = ', '.join(TRANSFORMERS.keys())
+        raise ValueError(f"Unsupported transformation type '{transform_type}'. Available types: {available}")
+
+    return TRANSFORMERS[transform_type]()
+
+
+def main():
+    """Main entry point for the gnps-transformer CLI."""
+    parser = argparse.ArgumentParser(
+        description=f"GNPS Transformer v{__version__} - Convert GNPS systems to various output formats",
+        prog='gnps-transformer'
+    )
+
+    parser.add_argument(
+        'gnps_files',
+        nargs='+',
+        help='GNPS system files (.yaml) to transform'
+    )
+
+    parser.add_argument(
+        '-t', '--type',
+        dest='transform_type',
+        required=True,
+        choices=list(TRANSFORMERS.keys()),
+        help='Transformation type'
+    )
+
+    parser.add_argument(
+        '-o', '--output-dir',
+        type=Path,
+        default=Path('.'),
+        help='Output directory for transformed files (default: current directory)'
+    )
+
+    parser.add_argument(
+        '--output-suffix',
+        default='',
+        help='Suffix to add to output filenames (before extension)'
+    )
+
+    parser.add_argument(
+        '-v', '--verbose',
+        action='store_true',
+        help='Enable verbose output'
+    )
+
+    args = parser.parse_args()
+
+    # Ensure output directory exists
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Get transformer
+    try:
+        transformer = get_transformer(args.transform_type)
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Process each file
+    for gnps_file_path in args.gnps_files:
+        gnps_file = Path(gnps_file_path)
+
+        if not gnps_file.exists():
+            print(f"Error: File '{gnps_file}' not found", file=sys.stderr)
+            continue
+
+        if args.verbose:
+            print(f"Processing: {gnps_file}")
+
+        try:
+            # Load GNPS system
+            gnps_system = GnpsSystem.from_yaml(str(gnps_file))
+
+            # Transform to target format
+            transformed_code = transformer.transform(gnps_system)
+
+            # Generate output filename
+            base_name = gnps_file.stem
+            if args.output_suffix:
+                base_name += args.output_suffix
+
+            output_file = args.output_dir / (base_name + transformer.get_file_extension())
+
+            # Write output
+            with open(output_file, 'w', encoding='utf-8') as f:
+                f.write(transformed_code)
+
+            if args.verbose:
+                print(f"  -> {output_file}")
+
+        except Exception as e:
+            print(f"Error processing '{gnps_file}': {e}", file=sys.stderr)
+            if args.verbose:   # pragma: no cover
+                import traceback
+                traceback.print_exc()
+            continue
+
+    if args.verbose:
+        print("Transformation complete.")
+
+
+if __name__ == '__main__':
+    main()

gnps-0.0.0/src/gnps/parser/__init__.py

@@ -0,0 +1,6 @@
+from .parser import (
+    parse_expression,
+    parse_condition,
+    parse_rule,
+    parse_variable_assignment
+)

gnps-0.0.0/src/gnps/parser/ast/__init__.py

@@ -0,0 +1,31 @@
+from .variable import Variable
+
+from .expression import (
+    Expression,
+    ConstantExpression,
+    VariableExpression,
+    BinaryExpression,
+    SumExpression,
+    DifferenceExpression,
+    MultiplicationExpression,
+    DivisionExpression,
+    UnaryMinusExpression,
+    IntOperationExpression,
+    IntMultiplicationExpression,
+    IntDivisionExpression,
+    )
+
+from .boolean_expression import (
+    BooleanExpression,
+    BooleanConstantExpression,
+    BooleanBinaryExpression,
+    BooleanAndExpression,
+    BooleanOrExpression,
+    BooleanNotExpression,
+    BooleanLessTestExpression,
+    BooleanLessEqualTestExpression,
+    BooleanGreaterTestExpression,
+    BooleanGreaterEqualTestExpression,
+    BooleanEqualTestExpression,
+    BooleanNotEqualTestExpression,
+    )

gnps-0.0.0/src/gnps/parser/ast/boolean_expression.py

@@ -0,0 +1,151 @@
+from abc import abstractmethod, ABC
+
+from .expression import Expression
+from .variable import Variable
+
+
+class BooleanExpression(Expression):
+    @abstractmethod
+    def evaluate(self) -> bool:
+        pass  # pragma: no cover
+
+
+class BooleanConstantExpression(BooleanExpression):
+    value: bool
+
+    def __init__(self, value: bool):
+        self.value = value
+
+    def evaluate(self):
+        return self.value
+
+    def get_variables(self) -> dict[str, Variable]:
+        return {}
+
+    def __str__(self):
+        return self.value.__str__()
+
+    def __repr__(self):
+        return f"BooleanConstantExpression({self.value})"
+
+
+class BooleanTestExpression(BooleanExpression, ABC):
+    def __init__(self, left: Expression, right: Expression, op: str = ''):
+        self.left = left
+        self.right = right
+        self.op = op
+
+    def __str__(self):
+        ll = self.left.__str__()
+        r = self.right.__str__()
+        return f"({ll} {self.op} {r})"
+
+    def __repr__(self):
+        return f"BooleanTestExpression('{self.op}',{self.left.__repr__()},{self.right.__repr__()})"
+
+    def get_variables(self) -> dict[str, Variable]:
+        variables = self.left.get_variables()
+        variables.update(self.right.get_variables())
+        return variables
+
+
+class BooleanGreaterTestExpression(BooleanTestExpression):
+    def __init__(self, left: Expression, right: Expression):
+        super().__init__(left, right, ">")
+
+    def evaluate(self):
+        return self.left.evaluate() > self.right.evaluate()
+
+
+class BooleanGreaterEqualTestExpression(BooleanTestExpression):
+    def __init__(self, left: Expression, right: Expression):
+        super().__init__(left, right, ">=")
+
+    def evaluate(self):
+        return self.left.evaluate() >= self.right.evaluate()
+
+
+class BooleanEqualTestExpression(BooleanTestExpression):
+    def __init__(self, left: Expression, right: Expression):
+        super().__init__(left, right, "==")
+
+    def evaluate(self):
+        return self.left.evaluate() == self.right.evaluate()
+
+
+class BooleanNotEqualTestExpression(BooleanTestExpression):
+    def __init__(self, left: Expression, right: Expression):
+        super().__init__(left, right, "!=")
+
+    def evaluate(self):
+        return self.left.evaluate() != self.right.evaluate()
+
+
+class BooleanLessTestExpression(BooleanTestExpression):
+    def __init__(self, left: Expression, right: Expression):
+        super().__init__(left, right, "<")
+
+    def evaluate(self):
+        return self.left.evaluate() < self.right.evaluate()
+
+
+class BooleanLessEqualTestExpression(BooleanTestExpression):
+    def __init__(self, left: Expression, right: Expression):
+        super().__init__(left, right, "<=")
+
+    def evaluate(self):
+        return self.left.evaluate() <= self.right.evaluate()
+
+
+class BooleanBinaryExpression(BooleanExpression, ABC):
+    def __init__(self, left: BooleanExpression, right: BooleanExpression, op: str = ''):
+        self.left = left
+        self.right = right
+        self.op = op
+
+    def __str__(self):
+        ll = self.left.__str__()
+        r = self.right.__str__()
+        return f"({ll} {self.op} {r})"
+
+    def __repr__(self):
+        return f"BooleanBinaryExpression('{self.op}',{self.left.__repr__()},{self.right.__repr__()})"
+
+    def get_variables(self) -> dict[str, Variable]:
+        variables = self.left.get_variables()
+        variables.update(self.right.get_variables())
+        return variables
+
+
+class BooleanOrExpression(BooleanBinaryExpression):
+    def __init__(self, left: BooleanExpression, right: BooleanExpression):
+        super().__init__(left, right, '||')
+
+    def evaluate(self):
+        return self.left.evaluate() or self.right.evaluate()
+
+
+class BooleanAndExpression(BooleanBinaryExpression):
+    def __init__(self, left: BooleanExpression, right: BooleanExpression):
+        super().__init__(left, right, '&&')
+
+    def evaluate(self):
+        return self.left.evaluate() and self.right.evaluate()
+
+
+class BooleanNotExpression(BooleanExpression):
+    def __init__(self, expression: BooleanExpression):
+        self.expression = expression
+
+    def evaluate(self):
+        return not self.expression.evaluate()
+
+    def __str__(self):
+        exp = self.expression.__str__()
+        return f"!({exp})"
+
+    def __repr__(self):
+        return f"BooleanNotExpression({self.expression.__repr__()})"
+
+    def get_variables(self) -> dict[str, Variable]:
+        return self.expression.get_variables()