regelum 0.1.0__tar.gz

regelum-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2015 Pavel Osinenko
+
+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.

regelum-0.1.0/PKG-INFO

@@ -0,0 +1,222 @@
+Metadata-Version: 2.3
+Name: regelum
+Version: 0.1.0
+Summary: Regelum is a flexibly configurable framework for computational graph construction and execution.
+License: MIT
+Author: Georgiy Malaniya
+Author-email: pwlsd.gm@gmail.com
+Requires-Python: >=3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: dev
+Requires-Dist: black (>=24.3.0) ; extra == "dev"
+Requires-Dist: casadi (>=3.6.7)
+Requires-Dist: dask[complete] (>=2024.12.1)
+Requires-Dist: graphviz (>=0.20.3)
+Requires-Dist: loguru (>=0.7.3)
+Requires-Dist: matplotlib (>=3.9.2)
+Requires-Dist: mkdocs-autorefs (>=1.2.0) ; extra == "dev"
+Requires-Dist: mkdocs-gen-files (>=0.5.0) ; extra == "dev"
+Requires-Dist: mkdocs-jupyter (>=0.25.1) ; extra == "dev"
+Requires-Dist: mkdocs-literate-nav (>=0.6.1) ; extra == "dev"
+Requires-Dist: mkdocs-macros-plugin (>=1.0.5) ; extra == "dev"
+Requires-Dist: mkdocs-material (>=9.5.47) ; extra == "dev"
+Requires-Dist: mkdocs-section-index (>=0.3.8) ; extra == "dev"
+Requires-Dist: mypy (>=1.8.0) ; extra == "dev"
+Requires-Dist: omegaconf (>=2.3.0)
+Requires-Dist: opencv-python (>=4.11.0.86)
+Requires-Dist: pandas (>=2.2.3)
+Requires-Dist: pre-commit (>=3.6.0) ; extra == "dev"
+Requires-Dist: pygame (>=2.6.1)
+Requires-Dist: pylint (>=3.0.3) ; extra == "dev"
+Requires-Dist: pytest (>=8.3.4) ; extra == "dev"
+Requires-Dist: pytest-cov (>=4.1.0) ; extra == "dev"
+Requires-Dist: ruff (>=0.3.0) ; extra == "dev"
+Requires-Dist: scipy (>=1.14.1)
+Requires-Dist: torch (>=2.4.1)
+Requires-Dist: types-PyYAML (>=6.0.12) ; extra == "dev"
+Requires-Dist: types-requests (>=2.32.0.20241016) ; extra == "dev"
+Requires-Dist: types-setuptools (>=75.6.0.20241223) ; extra == "dev"
+Description-Content-Type: text/markdown
+
+# Regelum
+
+![Pylint](https://img.shields.io/badge/pylint-9.59%2F10-brightgreen)
+![Coverage](https://img.shields.io/badge/coverage-0%25-red)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+![Black](https://img.shields.io/badge/Black-failing-red)
+
+Regelum (German: "to control") is a powerful framework for reinforcement learning, simulation, and control systems. It provides a modular, node-based architecture for building dynamic simulation pipelines with minimal overhead.
+
+## Key Features
+
+- **🔌 Modular Node Architecture**
+  - Build complex systems using independent, composable nodes
+  - Easy to extend and modify without affecting other components
+  - Shared global variable scope for seamless data flow
+
+- **🔄 Synchronous Loop Design**
+  - Optimized for reinforcement learning tasks
+  - Predictable execution flow
+  - Built-in state management
+
+- **📊 Integrated Tools**
+  - Real-time logging and visualization
+  - MathJax-powered documentation
+  - Jupyter notebook integration
+  - Automatic code quality checks
+
+- **🚀 Production Ready**
+  - Type-checked with MyPy
+  - Comprehensive linting (Pylint score: 9.5+/10)
+  - Pre-commit hooks for code quality
+  - Extensive documentation
+
+## Installation
+
+### For Users
+```bash
+pip install regelum
+```
+
+### For Developers
+```bash
+pip install -e ".[dev]"
+```
+
+## Quick Start
+
+Here's a practical example of controlling a pendulum using LQR with visualization:
+
+```python
+from regelum.node.classic_control.envs.continuous import Pendulum
+from regelum.node.classic_control.controllers.lqr import LQRController
+from regelum.node.visualization.pygame_renderer import PendulumRenderer
+from regelum.node.graph import Graph
+from regelum.node.reset import ResetEachNSteps
+
+# Create pendulum system
+pendulum = Pendulum(
+    control_signal_name="lqr_1.action",
+    initial_state=np.array([np.pi, 0.0])
+)
+
+# Configure LQR controller
+A = np.array([[0, 1], [-3 * pendulum.gravity_acceleration / (2 * pendulum.length), 0]])
+B = np.array([[0], [1 / pendulum.mass]])
+Q = np.diag([10.0, 1.0])  # State cost matrix
+R = np.array([[0.1]])      # Control cost matrix
+
+lqr = LQRController(
+    controlled_state=pendulum.state,
+    system_matrices=(A, B),
+    cost_matrices=(Q, R),
+    control_limits=(-10.0, 10.0),
+    step_size=0.01
+)
+
+# Add visualization
+viz = PendulumRenderer(
+    state_variable=pendulum.state,
+    fps=60.0,
+    window_size=(1200, 400),
+    visible_history=1000
+)
+
+# Reset pendulum periodically
+reset_node = ResetEachNSteps(
+    node_name_to_reset=pendulum.external_name,
+    n_steps=1000
+)
+
+# Create and run computation graph
+graph = Graph(
+    [pendulum, lqr, viz, reset_node],
+    initialize_inner_time=True,
+    states_to_log=[pendulum.state.full_name, lqr.action.full_name]
+)
+graph.resolve(graph.variables)
+
+# Run simulation
+for _ in range(5000):
+    graph.step()
+```
+
+This example demonstrates key features of Regelum:
+- Modular node-based architecture
+- Built-in controllers (LQR, PID, MPC)
+- Real-time visualization
+- Automatic state management
+- Easy system composition
+
+For more advanced examples, check out:
+- State estimation with UKF
+- Model predictive control
+- Custom reward functions
+- Advanced visualization
+
+## Documentation
+
+Visit our [documentation](https://aidagroup.github.io/regelum/) for:
+- Detailed tutorials and examples
+- API reference
+- Mathematical foundations
+- Best practices
+
+## Development
+
+We use several tools to maintain code quality:
+
+- **Type Checking**: MyPy with strict settings
+- **Linting**: Ruff and Pylint
+- **Formatting**: Black
+- **Testing**: Pytest
+- **Pre-commit**: Automated checks before commits
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Run tests and ensure code quality:
+   ```bash
+   pre-commit run --all-files
+   pytest
+   ```
+5. Submit a pull request
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Authors
+
+- Georgiy Malaniya
+- Pavel Osinenko
+- Anton Bolychev
+- Grigory Yaremenko
+
+## Origin
+
+Created by Pavel Osinenko, 2015-2016  
+Dresden/Chemnitz, Germany
+
+## Citation
+
+If you use Regelum in your research, please cite:
+
+```bibtex
+@software{regelum2024,
+  author = {Malaniya, Georgiy and Osinenko, Pavel and Bolychev, Anton and Yaremenko, Grigory},
+  title = {Regelum: A Framework for Reinforcement Learning and Control},
+  year = {2024},
+  publisher = {GitHub},
+  url = {https://github.com/aidagroup/regelum}
+}
+```
+
+
+

regelum-0.1.0/README.md

@@ -0,0 +1,178 @@
+# Regelum
+
+![Pylint](https://img.shields.io/badge/pylint-9.59%2F10-brightgreen)
+![Coverage](https://img.shields.io/badge/coverage-0%25-red)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+![Black](https://img.shields.io/badge/Black-failing-red)
+
+Regelum (German: "to control") is a powerful framework for reinforcement learning, simulation, and control systems. It provides a modular, node-based architecture for building dynamic simulation pipelines with minimal overhead.
+
+## Key Features
+
+- **🔌 Modular Node Architecture**
+  - Build complex systems using independent, composable nodes
+  - Easy to extend and modify without affecting other components
+  - Shared global variable scope for seamless data flow
+
+- **🔄 Synchronous Loop Design**
+  - Optimized for reinforcement learning tasks
+  - Predictable execution flow
+  - Built-in state management
+
+- **📊 Integrated Tools**
+  - Real-time logging and visualization
+  - MathJax-powered documentation
+  - Jupyter notebook integration
+  - Automatic code quality checks
+
+- **🚀 Production Ready**
+  - Type-checked with MyPy
+  - Comprehensive linting (Pylint score: 9.5+/10)
+  - Pre-commit hooks for code quality
+  - Extensive documentation
+
+## Installation
+
+### For Users
+```bash
+pip install regelum
+```
+
+### For Developers
+```bash
+pip install -e ".[dev]"
+```
+
+## Quick Start
+
+Here's a practical example of controlling a pendulum using LQR with visualization:
+
+```python
+from regelum.node.classic_control.envs.continuous import Pendulum
+from regelum.node.classic_control.controllers.lqr import LQRController
+from regelum.node.visualization.pygame_renderer import PendulumRenderer
+from regelum.node.graph import Graph
+from regelum.node.reset import ResetEachNSteps
+
+# Create pendulum system
+pendulum = Pendulum(
+    control_signal_name="lqr_1.action",
+    initial_state=np.array([np.pi, 0.0])
+)
+
+# Configure LQR controller
+A = np.array([[0, 1], [-3 * pendulum.gravity_acceleration / (2 * pendulum.length), 0]])
+B = np.array([[0], [1 / pendulum.mass]])
+Q = np.diag([10.0, 1.0])  # State cost matrix
+R = np.array([[0.1]])      # Control cost matrix
+
+lqr = LQRController(
+    controlled_state=pendulum.state,
+    system_matrices=(A, B),
+    cost_matrices=(Q, R),
+    control_limits=(-10.0, 10.0),
+    step_size=0.01
+)
+
+# Add visualization
+viz = PendulumRenderer(
+    state_variable=pendulum.state,
+    fps=60.0,
+    window_size=(1200, 400),
+    visible_history=1000
+)
+
+# Reset pendulum periodically
+reset_node = ResetEachNSteps(
+    node_name_to_reset=pendulum.external_name,
+    n_steps=1000
+)
+
+# Create and run computation graph
+graph = Graph(
+    [pendulum, lqr, viz, reset_node],
+    initialize_inner_time=True,
+    states_to_log=[pendulum.state.full_name, lqr.action.full_name]
+)
+graph.resolve(graph.variables)
+
+# Run simulation
+for _ in range(5000):
+    graph.step()
+```
+
+This example demonstrates key features of Regelum:
+- Modular node-based architecture
+- Built-in controllers (LQR, PID, MPC)
+- Real-time visualization
+- Automatic state management
+- Easy system composition
+
+For more advanced examples, check out:
+- State estimation with UKF
+- Model predictive control
+- Custom reward functions
+- Advanced visualization
+
+## Documentation
+
+Visit our [documentation](https://aidagroup.github.io/regelum/) for:
+- Detailed tutorials and examples
+- API reference
+- Mathematical foundations
+- Best practices
+
+## Development
+
+We use several tools to maintain code quality:
+
+- **Type Checking**: MyPy with strict settings
+- **Linting**: Ruff and Pylint
+- **Formatting**: Black
+- **Testing**: Pytest
+- **Pre-commit**: Automated checks before commits
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Run tests and ensure code quality:
+   ```bash
+   pre-commit run --all-files
+   pytest
+   ```
+5. Submit a pull request
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Authors
+
+- Georgiy Malaniya
+- Pavel Osinenko
+- Anton Bolychev
+- Grigory Yaremenko
+
+## Origin
+
+Created by Pavel Osinenko, 2015-2016  
+Dresden/Chemnitz, Germany
+
+## Citation
+
+If you use Regelum in your research, please cite:
+
+```bibtex
+@software{regelum2024,
+  author = {Malaniya, Georgiy and Osinenko, Pavel and Bolychev, Anton and Yaremenko, Grigory},
+  title = {Regelum: A Framework for Reinforcement Learning and Control},
+  year = {2024},
+  publisher = {GitHub},
+  url = {https://github.com/aidagroup/regelum}
+}
+```
+
+

regelum-0.1.0/pyproject.toml

@@ -0,0 +1,103 @@
+[project]
+name = "regelum"
+version = "0.1.0"
+description = "Regelum is a flexibly configurable framework for computational graph construction and execution."
+authors = [
+    {name = "Georgiy Malaniya", email = "pwlsd.gm@gmail.com"},
+    {name = "Anton Bolychev", email = "bolychev.anton@gmail.com"},
+    {name = "Grigoriy Yaremenko", email = "yaremenko8@gmail.com"},
+    {name = "Pavel Osinenko", email = "p.osinenko@yandex.ru"}
+]
+requires-python = ">=3.12"
+readme = "README.md"
+license = {text = "MIT"}
+dependencies = [
+    "opencv-python>=4.11.0.86",
+    "pygame>=2.6.1",
+    "casadi>=3.6.7",
+    "torch>=2.4.1",
+    "pandas>=2.2.3",
+    "omegaconf>=2.3.0",
+    "scipy>=1.14.1",
+    "matplotlib>=3.9.2",
+    "loguru>=0.7.3",
+    "dask[complete]>=2024.12.1",
+    "graphviz>=0.20.3",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.3.4",
+    "pytest-cov>=4.1.0",
+    "pre-commit>=3.6.0",
+    "mkdocs-material>=9.5.47",
+    "mkdocs-autorefs>=1.2.0",
+    "mkdocs-macros-plugin>=1.0.5",
+    "mkdocs-gen-files>=0.5.0",
+    "mkdocs-literate-nav>=0.6.1",
+    "mkdocs-section-index>=0.3.8",
+    "mkdocs-jupyter>=0.25.1",
+    "black>=24.3.0",
+    "ruff>=0.3.0",
+    "mypy>=1.8.0",
+    "pylint>=3.0.3",
+    "types-PyYAML>=6.0.12",
+    "types-setuptools>=75.6.0.20241223",
+    "types-requests>=2.32.0.20241016",
+]
+
+
+[tool.poetry.extras]
+dev = [
+    "pytest",
+    "pytest-cov",
+    "pre-commit",
+    "mkdocs-material",
+    "black",
+    "ruff",
+    "mypy",
+    "pylint",
+    "types-PyYAML",
+    "types-setuptools",
+    "types-requests",
+    "mkdocs-autorefs",
+    "mkdocs-macros-plugin",
+    "mkdocs-gen-files",
+    "mkdocs-literate-nav",
+    "mkdocs-section-index",
+    "mkdocs-jupyter"
+]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[dependency-groups]
+dev = [
+    "mkdocstrings>=0.29.0",
+    "mkdocstrings-python>=1.16.8",
+]
+
+[tool.pytest.ini_options]
+addopts = "--cov=regelum --cov-report=term-missing"
+testpaths = ["tests"]
+
+[tool.coverage.run]
+source = ["regelum"]
+omit = [
+    "regelum/utils/*",
+    "regelum/node/visualization/*",
+    "regelum/node/classic_control/*",
+    "tests/*",
+    "examples/*",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "pass",
+    "raise ImportError",
+]

regelum-0.1.0/regelum/__init__.py

@@ -0,0 +1,82 @@
+"""Regelum: A High-Performance Node-Based Computation Framework.
+
+Regelum is a powerful framework for building and executing computational graphs,
+with support for parallel execution, symbolic computation, and automatic dependency resolution.
+
+Key Features:
+- Node-based computation with automatic dependency tracking
+- Parallel execution using Dask
+- Symbolic computation support via CasADi
+- Flexible graph composition and manipulation
+- Built-in logging and debugging tools
+"""
+
+from contextlib import contextmanager
+from typing import Dict, Any, Iterator
+
+from regelum.node.core.globals import _SYMBOLIC_INFERENCE_ACTIVE
+from regelum.node.core.variable import Variable
+from regelum.node.core.inputs import Inputs
+
+__version__ = "1.0.0"
+__author__ = "Regelum Team"
+__license__ = "MIT"
+
+# Core components
+from regelum.node.base import Node
+from regelum.node.core.types import ResolveStatus
+from regelum.node.graph import Graph
+from regelum.node.logging import Clock, StepCounter, Logger
+from regelum.node.parallel import ParallelGraph
+
+
+@contextmanager
+def symbolic_mode() -> Iterator[None]:
+    """Context manager for symbolic mode."""
+    _SYMBOLIC_INFERENCE_ACTIVE.value = True
+    try:
+        yield
+    finally:
+        _SYMBOLIC_INFERENCE_ACTIVE.value = False
+
+
+def get_version() -> str:
+    """Get the version of Regelum."""
+    return __version__
+
+
+# Package metadata
+metadata: Dict[str, Any] = {
+    "name": "regelum",
+    "version": __version__,
+    "author": __author__,
+    "license": __license__,
+    "description": "High-Performance Node-Based Computation Framework",
+    "requires": [
+        "numpy",
+        "casadi",
+        "torch",
+        "dask",
+        "dask.distributed",
+    ],
+}
+
+__all__ = [
+    # Core classes
+    "Node",
+    "Graph",
+    "ParallelGraph",
+    "Variable",
+    "Inputs",
+    # Utility nodes
+    "Clock",
+    "StepCounter",
+    "Logger",
+    # Enums and status
+    "ResolveStatus",
+    # Context managers
+    "symbolic_mode",
+    # Version and metadata
+    "get_version",
+    "metadata",
+]

regelum-0.1.0/regelum/node/__init__.py

@@ -0,0 +1,61 @@
+"""Node system for building computational graphs.
+
+This package provides a flexible framework for building and executing computational
+graphs with a focus on control systems and simulation. It supports:
+
+Core Components:
+- Nodes: Self-contained computational units with state
+- Variables: Type-safe data containers with reset capabilities
+- Graphs: Containers that manage node execution and dependencies
+- Parallel Execution: Task-based parallelism using Dask
+
+Key Features:
+1. Dependency Management:
+   - Automatic resolution of node dependencies
+   - Full variable name qualification (node_name.variable_name)
+   - Circular dependency detection
+
+2. Execution Control:
+   - Mixed continuous/discrete time dynamics
+   - Coordinated reset behavior
+   - Parallel execution with dependency preservation
+
+3. State Management:
+   - Automatic variable tracking
+   - Configurable reset behavior
+   - Monte Carlo simulation support
+
+Example:
+    ```python
+    from regelum.node import Node, Graph
+
+    # Define a node
+    class Controller(Node):
+        def __init__(self):
+            super().__init__(
+                inputs=["plant_1.state"],
+                step_size=0.01
+            )
+            self.action = self.define_variable("action", value=0.0)
+
+        def step(self):
+            # Implement control logic
+            pass
+
+    # Create and run a graph
+    plant = Plant()
+    controller = Controller()
+    graph = Graph(
+        [plant, controller],
+        initialize_inner_time=True
+    )
+    graph.resolve(graph.variables)
+    graph.step()
+    ```
+
+The package is designed for:
+- Control system simulation
+- Reinforcement learning environments
+- Real-time data processing
+- Distributed computation
+"""