How marekwadinger/sippy works
Project type and purpose
• SIPPY is an open-source Python library for linear system identification of dynamical systems. It provides algorithms for input–output models (ARX, ARMAX, etc.) and state-space methods (N4SID, PARSIM, etc.).
• There is no client–server or GUI; the “system” is a modular library invoked via a Python API or Jupyter notebooks.
File structure
• Top-level artifacts:
• sippy_unipi/ ← core Python package
• docs/ ← documentation (MkDocs, examples, tutorials)
• benchmarks/ ← performance scripts
• CI/CD config: .github/, Dockerfile, Makefile, mkdocs.yml
• Core package submodules under sippy_unipi/:
• datasets/ ← data-loading and synthetic data generators
• io/ ← import/export routines for different model types
• preprocessing.py ← data pre-conditioning utilities
• tf2ss/ ← transfer-function-to-state-space conversion
• ss/ ← state-space identification algorithms
• model_selection.py ← selection of best model structure
• evaluate.py ← metrics and result evaluation
• utils/ ← shared helpers, validation, base classes
• There is a single entry-point API function: system_identification (in __init__.py).
README for additional insights
• Lists supported algorithms and features (FIR, ARX, ARMAX… N4SID, MOESP… etc.)
• Quickstart demonstrates how the user calls system_identification() with data
• Installation and Dockerization indicate deployment contexts.
• User / Client Layer
• Data Sources
• User-provided time series (Y, U)
• Built-in sample datasets
• API Layer
• system_identification() entry point
• Core Processing Modules (layered):
1. Preprocessing Module
2. IO Module (format parsing, data interfacing)
3. Algorithm Modules
– Input–Output Algorithms (ARX, ARMAX, …)
– State–Space Algorithms (N4SID, PARSIM, …)
– Transfer-Function converters (tf2ss)
4. Model Selection Module
5. Evaluation Module
• Utilities Module (cross-cutting)
• External Integrations
• Jupyter Notebooks (docs/examples)
• Documentation (MkDocs site)
• CI/CD Pipelines (GitHub Actions, Docker)
• Packaging (PyPI)
b. Relationships and interactions
• The User invokes the system_identification API →
• Data flows from Data Sources → Preprocessing → IO Module →
• Processed data passed to the selected Algorithm Module →
• Output model passed to Model Selection →
• Final model evaluated by Evaluation Module →
• Results returned to User or passed to downstream analysis
• Utilities are invoked by all internal modules as needed
• Docs and examples reference the same API and modules
• CI/CD and Docker connect to the repo for testing, building, and publishing
c. Architectural patterns and design principles
• Layered architecture: clear separation between data ingestion, processing, algorithms, selection, and evaluation
• Modular design: each algorithm family lives in its own subpackage
• Single public entry point (system_identification) for consistent API
• Cross-cutting concerns handled by utils (validation, base classes)
• Decoupling of core library from documentation and CI
d. Key technologies, frameworks, libraries
• Python 3.10+
• NumPy/SciPy (implied by algorithms)
• MkDocs for documentation
• Jupyter for interactive examples
• Docker for environment reproducibility
• GitHub Actions for CI/CD
• Poetry (pyproject.toml) for packaging