circuit-static-description 0.1.0__py3-none-any.whl

circuit_static_description/__init__.py

@@ -0,0 +1,10 @@
+"""Circuit static description Python package."""
+
+from .circuit import Circuit, CircuitError, CircuitFormatError
+
+__all__ = ["Circuit", "CircuitError", "CircuitFormatError"]
+
+
+def main() -> None:
+    """Simple package entry point for basic verification."""
+    print("circuit_static_description package is available")

circuit_static_description/circuit.py

@@ -0,0 +1,212 @@
+"""Circuit load/save/evaluate implementation for boolean gate circuits."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, List, Sequence, Tuple
+
+
+class CircuitError(Exception):
+    """Base exception raised by circuit_static_description."""
+
+
+class CircuitFormatError(CircuitError):
+    """Raised when a circuit description file cannot be parsed."""
+
+
+@dataclass(frozen=True)
+class _ExprNode:
+    op: str
+    args: Tuple["_ExprNode", ...] = ()
+    input_index: int | None = None
+
+
+class Circuit:
+    """A boolean logic circuit with only input count, output count and output expressions."""
+
+    SUPPORTED_OPS = {
+        "AND": 2,
+        "OR": 2,
+        "NOT": 1,
+        "XOR": 2,
+        "NAND": 2,
+        "NOR": 2,
+    }
+
+    def __init__(self, input_count: int, output_count: int, outputs: List[str] | None = None) -> None:
+        if input_count < 1:
+            raise CircuitError("input_count must be at least 1")
+        if output_count < 1:
+            raise CircuitError("output_count must be at least 1")
+        self.input_count = input_count
+        self.output_count = output_count
+        self.outputs = outputs or ["" for _ in range(output_count)]
+        if len(self.outputs) != self.output_count:
+            raise CircuitError("outputs length must match output_count")
+
+    def save(self, path: str | Path) -> None:
+        path = Path(path)
+        path.write_text(self.to_text(), encoding="utf-8")
+
+    def to_text(self) -> str:
+        lines: List[str] = [f"INPUTS {self.input_count}", f"OUTPUTS {self.output_count}"]
+        for index, expression in enumerate(self.outputs):
+            lines.append(f"OUT{index} = {expression}")
+        return "\n".join(lines) + "\n"
+
+    @classmethod
+    def load(cls, path: str | Path) -> "Circuit":
+        path = Path(path)
+        return cls.from_text(path.read_text(encoding="utf-8"))
+
+    @classmethod
+    def from_text(cls, text: str) -> "Circuit":
+        lines = [line.split("#", 1)[0].strip() for line in text.splitlines()]
+        lines = [line for line in lines if line]
+        if len(lines) < 2:
+            raise CircuitFormatError("Circuit description must include INPUTS and OUTPUTS")
+
+        def parse_header(prefix: str, line: str) -> int:
+            if not line.upper().startswith(prefix):
+                raise CircuitFormatError(f"Expected '{prefix}' header, got: {line}")
+            parts = line.split(None, 1)
+            if len(parts) != 2 or not parts[1].isdigit():
+                raise CircuitFormatError(f"Invalid {prefix} header: {line}")
+            return int(parts[1])
+
+        input_count = parse_header("INPUTS", lines[0])
+        output_count = parse_header("OUTPUTS", lines[1])
+        if len(lines) != output_count + 2:
+            raise CircuitFormatError(
+                f"Expected {output_count} output lines after headers, got {len(lines) - 2}"
+            )
+
+        outputs: List[str] = []
+        for index, line in enumerate(lines[2:]):
+            if "=" not in line:
+                raise CircuitFormatError(f"Missing '=' on output line {index}: {line}")
+            name, expr = [part.strip() for part in line.split("=", 1)]
+            expected_name = f"OUT{index}"
+            if name.upper() != expected_name:
+                raise CircuitFormatError(f"Expected output name '{expected_name}', got '{name}'")
+            if not expr:
+                raise CircuitFormatError(f"Empty expression for {expected_name}")
+            outputs.append(expr)
+
+        circuit = cls(input_count=input_count, output_count=output_count, outputs=outputs)
+        return circuit
+
+    def evaluate(self, inputs: Sequence[Any]) -> List[int]:
+        if len(inputs) != self.input_count:
+            raise CircuitError(
+                f"Expected {self.input_count} input values, got {len(inputs)}"
+            )
+        parsed_outputs = [self._parse_expression(expression) for expression in self.outputs]
+        return [int(bool(self._evaluate_node(node, inputs))) for node in parsed_outputs]
+
+    def _parse_expression(self, text: str) -> _ExprNode:
+        text = text.strip()
+        if not text:
+            raise CircuitFormatError("Expression cannot be empty")
+        parser = _ExpressionParser(text)
+        node = parser.parse()
+        if not parser.is_done():
+            raise CircuitFormatError(f"Unexpected text after expression: {parser.remaining_text()}")
+        return node
+
+    def _evaluate_node(self, node: _ExprNode, inputs: Sequence[Any]) -> bool:
+        if node.op == "INPUT":
+            assert node.input_index is not None
+            if node.input_index < 0 or node.input_index >= len(inputs):
+                raise CircuitError(f"Input reference I{node.input_index} is out of range")
+            return bool(inputs[node.input_index])
+        values = [self._evaluate_node(child, inputs) for child in node.args]
+        if node.op == "AND":
+            return values[0] and values[1]
+        if node.op == "OR":
+            return values[0] or values[1]
+        if node.op == "NOT":
+            return not values[0]
+        if node.op == "XOR":
+            return values[0] ^ values[1]
+        if node.op == "NAND":
+            return not (values[0] and values[1])
+        if node.op == "NOR":
+            return not (values[0] or values[1])
+        raise CircuitError(f"Unsupported operator during evaluation: {node.op}")
+
+
+class _ExpressionParser:
+    def __init__(self, text: str) -> None:
+        self.text = text
+        self.pos = 0
+
+    def parse(self) -> _ExprNode:
+        node = self._parse_term()
+        return node
+
+    def is_done(self) -> bool:
+        self._skip_whitespace()
+        return self.pos >= len(self.text)
+
+    def remaining_text(self) -> str:
+        return self.text[self.pos :].strip()
+
+    def _parse_term(self) -> _ExprNode:
+        self._skip_whitespace()
+        if self._peek().isalpha():
+            token = self._parse_identifier().upper()
+            if token.startswith("I") and token[1:].isdigit():
+                index = int(token[1:])
+                if index < 0:
+                    raise CircuitFormatError(f"Invalid input reference: {token}")
+                return _ExprNode(op="INPUT", input_index=index)
+            if token not in Circuit.SUPPORTED_OPS:
+                raise CircuitFormatError(f"Unsupported operator: {token}")
+            self._skip_whitespace()
+            if self._peek() != "(":
+                raise CircuitFormatError(f"Operator '{token}' requires parentheses")
+            self._consume("(")
+            args = self._parse_arguments(token)
+            self._consume(")")
+            expected = Circuit.SUPPORTED_OPS[token]
+            if len(args) != expected:
+                raise CircuitFormatError(
+                    f"Operator '{token}' expects {expected} arguments, got {len(args)}"
+                )
+            return _ExprNode(op=token, args=tuple(args))
+        raise CircuitFormatError("Expression must begin with an input reference or operator")
+
+    def _parse_arguments(self, operator: str) -> List[_ExprNode]:
+        arguments: List[_ExprNode] = []
+        while True:
+            self._skip_whitespace()
+            arguments.append(self._parse_term())
+            self._skip_whitespace()
+            if self._peek() == ")":
+                break
+            self._consume(",")
+        return arguments
+
+    def _parse_identifier(self) -> str:
+        start = self.pos
+        while self.pos < len(self.text) and self.text[self.pos].isalnum():
+            self.pos += 1
+        return self.text[start : self.pos]
+
+    def _skip_whitespace(self) -> None:
+        while self.pos < len(self.text) and self.text[self.pos].isspace():
+            self.pos += 1
+
+    def _peek(self) -> str:
+        self._skip_whitespace()
+        if self.pos >= len(self.text):
+            return ""
+        return self.text[self.pos]
+
+    def _consume(self, expected: str) -> None:
+        self._skip_whitespace()
+        if self.pos >= len(self.text) or self.text[self.pos] != expected:
+            raise CircuitFormatError(f"Expected '{expected}' at position {self.pos}")
+        self.pos += 1

circuit_static_description-0.1.0.dist-info/METADATA

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: circuit-static-description
+Version: 0.1.0
+Summary: A boolean gate circuit description package for saving, loading, and evaluating logic circuits.
+License: MIT
+License-File: LICENSE
+Keywords: circuit,boolean,logic
+Author: GGN_2015
+Author-email: neko@jlulug.org
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Description-Content-Type: text/markdown
+
+# circuit-static-description
+A text-based boolean gate circuit description format that is easy to save and port.
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install circuit-static-description
+```
+
+## Python package usage
+
+This project provides a Python package named `circuit_static_description`. The package supports saving circuits, loading circuits, and evaluating outputs.
+
+### Importing
+
+```python
+from circuit_static_description import Circuit
+```
+
+### Circuit description format
+
+A circuit description contains only the number of inputs, the number of outputs, and the expression for each output. There are no intermediate variable names.
+
+- Input references use `I0`, `I1`, `I2`, etc.
+- Output lines use fixed names `OUT0`, `OUT1`, etc.
+- Supported logic operators: `AND`, `OR`, `NOT`, `XOR`, `NAND`, `NOR`.
+
+Example:
+
+```text
+INPUTS 3
+OUTPUTS 2
+OUT0 = AND(I0, I1)
+OUT1 = NOR(I2, XOR(I0, I1))
+```
+
+### Saving a circuit
+
+```python
+from circuit_static_description import Circuit
+
+circuit = Circuit(
+    input_count=3,
+    output_count=2,
+    outputs=[
+        "AND(I0, I1)",
+        "NOR(I2, XOR(I0, I1))",
+    ],
+)
+
+circuit.save("example.circuit")
+```
+
+### Loading a circuit
+
+```python
+from circuit_static_description import Circuit
+
+circuit = Circuit.load("example.circuit")
+```
+
+### Evaluating a circuit
+
+```python
+result = circuit.evaluate([1, 0, 1])
+print(result)
+# Example output: [0, 0]
+```
+
+### Notes
+
+- `evaluate` accepts a list of input values in input order.
+- The output is returned as a list of `0` or `1` values.
+- Expressions cannot use custom variable names; they must use `I*` input references and supported logic operators.

circuit_static_description-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+circuit_static_description/__init__.py,sha256=6ALgrX2IErZnQk0inRs2hoTXDi8GN6Fu1VjJwcqjSO4,328
+circuit_static_description/circuit.py,sha256=SbdLzOylkLvmNsqi_VY6gLIxVAKa7mDwMr9rC0TRTnA,8382
+circuit_static_description-0.1.0.dist-info/licenses/LICENSE,sha256=gmkEFqkF3KJjRnhXGoLSfX4xXtfPHT1ghq3YgCF7B3w,1086
+circuit_static_description-0.1.0.dist-info/METADATA,sha256=8pwVimPn2Dgku78OHzCzg_WD-qXjiNJHENbZ8wy93LY,2362
+circuit_static_description-0.1.0.dist-info/WHEEL,sha256=EGEvSphFYqXKs23-kQBeyNoJP1nrT8ZJKQoi5p5DYL8,88
+circuit_static_description-0.1.0.dist-info/RECORD,,

circuit_static_description-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.4.0
+Root-Is-Purelib: true
+Tag: py3-none-any

circuit_static_description-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GGN_2015
+
+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 NONINFRINGEMENT. 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.