chronopype 0.1.0__tar.gz

chronopype-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Gianluca Pagliara
+
+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.

chronopype-0.1.0/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.1
+Name: chronopype
+Version: 0.1.0
+Summary: A flexible clock implementation for real-time and backtesting scenarios
+Author: Gianluca Pagliara
+Author-email: pagliara.gianluca@gmail.com
+Requires-Python: >=3.13,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: eventspype (>=0.1.0,<0.2.0)
+Requires-Dist: pydantic (>=2.10.4,<3.0.0)
+Description-Content-Type: text/markdown
+
+# Chrono Pypeline
+
+[![CI](https://github.com/gianlucapagliara/chronopype/actions/workflows/ci.yml/badge.svg)](https://github.com/gianlucapagliara/chronopype/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/gianlucapagliara/chronopype/branch/main/graph/badge.svg)](https://codecov.io/gh/gianlucapagliara/chronopype)
+[![Python 3.13+](https://img.shields.io/badge/python-3.13+-blue.svg)](https://www.python.org/downloads/)
+
+A flexible clock implementation for real-time and backtesting scenarios in Python. chronopype provides a robust framework for managing time-based operations with support for both real-time processing and historical data backtesting.
+
+## Features
+
+- 🕒 **Flexible Clock System**: Support for both real-time and backtesting modes
+- 🔄 **Processor Framework**: Extensible system for implementing time-based operations
+- 🌐 **Network-Aware**: Built-in network processor with retry and backoff capabilities
+- ⚡ **Async Support**: Full async/await support for efficient I/O operations
+- 🛠️ **Easy to Use**: Simple API for managing time-based operations
+- 📊 **Performance Monitoring**: Built-in performance tracking and statistics
+- 🔒 **Type Safe**: Fully typed with MyPy strict mode
+- 🧪 **Well Tested**: Comprehensive test suite with high coverage
+
+## Installation
+
+```bash
+# Using pip
+pip install chronopype
+
+# Using poetry
+poetry add chronopype
+```
+
+## Quick Start
+
+Here's a simple example of using chronopype:
+
+```python
+import asyncio
+from chronopype import ClockConfig
+from chronopype.clocks import RealtimeClock
+from chronopype.processors import TickProcessor
+
+class MyProcessor(TickProcessor):
+    async def async_tick(self, timestamp: float) -> None:
+        print(f"Processing at {timestamp}")
+
+async def main():
+    # Configure the clock
+    config = ClockConfig(
+        start_time=time.time(),
+        tick_size=1.0  # 1 second ticks
+    )
+
+    # Create and configure the clock
+    async with RealtimeClock(config) as clock:
+        # Add your processor
+        clock.add_processor(MyProcessor())
+
+        # Run for 10 seconds
+        await clock.run_til(config.start_time + 10)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Core Components
+
+- **Clocks**: Base implementations for time management
+  - `RealtimeClock`: For real-time processing
+  - `BacktestClock`: For historical data processing
+
+- **Processors**: Framework for implementing time-based operations
+  - `TickProcessor`: Base class for all processors
+  - `NetworkProcessor`: Network-aware processor with retry capabilities
+
+## Development
+
+chronopype uses Poetry for dependency management and packaging:
+
+```bash
+# Install dependencies
+poetry install
+
+# Run tests
+poetry run pytest
+
+# Run type checks
+poetry run mypy .
+
+# Run linting
+poetry run pre-commit run --all-files
+```
+

chronopype-0.1.0/README.md

@@ -0,0 +1,89 @@
+# Chrono Pypeline
+
+[![CI](https://github.com/gianlucapagliara/chronopype/actions/workflows/ci.yml/badge.svg)](https://github.com/gianlucapagliara/chronopype/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/gianlucapagliara/chronopype/branch/main/graph/badge.svg)](https://codecov.io/gh/gianlucapagliara/chronopype)
+[![Python 3.13+](https://img.shields.io/badge/python-3.13+-blue.svg)](https://www.python.org/downloads/)
+
+A flexible clock implementation for real-time and backtesting scenarios in Python. chronopype provides a robust framework for managing time-based operations with support for both real-time processing and historical data backtesting.
+
+## Features
+
+- 🕒 **Flexible Clock System**: Support for both real-time and backtesting modes
+- 🔄 **Processor Framework**: Extensible system for implementing time-based operations
+- 🌐 **Network-Aware**: Built-in network processor with retry and backoff capabilities
+- ⚡ **Async Support**: Full async/await support for efficient I/O operations
+- 🛠️ **Easy to Use**: Simple API for managing time-based operations
+- 📊 **Performance Monitoring**: Built-in performance tracking and statistics
+- 🔒 **Type Safe**: Fully typed with MyPy strict mode
+- 🧪 **Well Tested**: Comprehensive test suite with high coverage
+
+## Installation
+
+```bash
+# Using pip
+pip install chronopype
+
+# Using poetry
+poetry add chronopype
+```
+
+## Quick Start
+
+Here's a simple example of using chronopype:
+
+```python
+import asyncio
+from chronopype import ClockConfig
+from chronopype.clocks import RealtimeClock
+from chronopype.processors import TickProcessor
+
+class MyProcessor(TickProcessor):
+    async def async_tick(self, timestamp: float) -> None:
+        print(f"Processing at {timestamp}")
+
+async def main():
+    # Configure the clock
+    config = ClockConfig(
+        start_time=time.time(),
+        tick_size=1.0  # 1 second ticks
+    )
+
+    # Create and configure the clock
+    async with RealtimeClock(config) as clock:
+        # Add your processor
+        clock.add_processor(MyProcessor())
+
+        # Run for 10 seconds
+        await clock.run_til(config.start_time + 10)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Core Components
+
+- **Clocks**: Base implementations for time management
+  - `RealtimeClock`: For real-time processing
+  - `BacktestClock`: For historical data processing
+
+- **Processors**: Framework for implementing time-based operations
+  - `TickProcessor`: Base class for all processors
+  - `NetworkProcessor`: Network-aware processor with retry capabilities
+
+## Development
+
+chronopype uses Poetry for dependency management and packaging:
+
+```bash
+# Install dependencies
+poetry install
+
+# Run tests
+poetry run pytest
+
+# Run type checks
+poetry run mypy .
+
+# Run linting
+poetry run pre-commit run --all-files
+```

chronopype-0.1.0/chronopype/clocks/__init__.py

@@ -0,0 +1,32 @@
+"""Clock implementations package."""
+
+from .backtest import BacktestClock
+from .base import BaseClock
+from .modes import ClockMode
+from .realtime import RealtimeClock
+
+# Registry mapping clock modes to their implementations
+CLOCK_REGISTRY: dict[ClockMode, type[BaseClock]] = {
+    ClockMode.BACKTEST: BacktestClock,
+    ClockMode.REALTIME: RealtimeClock,
+}
+
+
+def get_clock_class(mode: ClockMode) -> type[BaseClock]:
+    """Get the clock class for a given mode.
+
+    Args:
+        mode: The clock mode to get the implementation for.
+
+    Returns:
+        The clock class for the given mode.
+
+    Raises:
+        ValueError: If no implementation exists for the given mode.
+    """
+    if mode not in CLOCK_REGISTRY:
+        raise ValueError(f"No clock implementation found for mode: {mode}")
+    return CLOCK_REGISTRY[mode]
+
+
+__all__ = ["BaseClock", "BacktestClock", "RealtimeClock", "ClockMode"]

chronopype-0.1.0/chronopype/clocks/backtest.py

@@ -0,0 +1,168 @@
+import asyncio
+from collections.abc import Callable
+
+from ..exceptions import ClockError
+from ..models import ClockConfig
+from ..processors.base import TickProcessor
+from .base import BaseClock
+from .modes import ClockMode
+
+
+class BacktestClock(BaseClock):
+    """Clock implementation for backtesting mode."""
+
+    start_publication = BaseClock.start_publication
+    tick_publication = BaseClock.tick_publication
+    stop_publication = BaseClock.stop_publication
+
+    def __init__(
+        self,
+        config: ClockConfig,
+        error_callback: Callable[[TickProcessor, Exception], None] | None = None,
+    ) -> None:
+        """Initialize a new BacktestClock instance."""
+        if config.clock_mode != ClockMode.BACKTEST:
+            raise ClockError("BacktestClock requires BACKTEST mode")
+        if config.end_time <= 0:
+            raise ClockError("end_time must be set for backtest mode")
+        super().__init__(config, error_callback)
+
+    def start(self) -> None:
+        """Start the clock."""
+        if not self._current_context:
+            raise ClockError("Clock must be started in a context")
+        self._started = True
+
+    def stop(self) -> None:
+        """Stop the clock."""
+        self._started = False
+        self._running = False
+
+    def tick(self) -> None:
+        """Process a clock tick."""
+        if not self._started:
+            raise ClockError("Clock not started")
+        self._tick_counter += 1
+        self._current_tick += self._config.tick_size
+
+    async def run(self) -> None:
+        """Run the clock until end_time."""
+        await self.run_til(self._config.end_time)
+
+    async def run_til(self, target_time: float) -> None:
+        """Run the clock until the target time."""
+        if self._task is not None:
+            raise ClockError("Clock is already running")
+
+        if not self._current_context:
+            raise ClockError("Clock must be started in a context")
+
+        if target_time > self._config.end_time:
+            raise ClockError("Cannot run past end_time in backtest mode")
+
+        self._running = True
+        self._started = True
+        self._task = asyncio.create_task(
+            self._run_til_impl(target_time, self._current_context)
+        )
+
+        # Activate all processors
+        for processor in self._current_context:
+            state = self._processor_states[processor]
+            self._processor_states[processor] = state.model_copy(
+                update={"is_active": True}
+            )
+
+        try:
+            await self._task
+        finally:
+            self._task = None
+
+    async def _run_til_impl(
+        self, target_time: float, processors: list[TickProcessor]
+    ) -> None:
+        """Run the clock until a specific timestamp."""
+        if not self._running:
+            raise ClockError("Clock must be started in a context.")
+
+        processors = [p for p in processors if self._processor_states[p].is_active]
+        if not processors:
+            return
+
+        # Calculate number of ticks needed
+        num_ticks = int((target_time - self._current_tick) / self._config.tick_size)
+        if num_ticks <= 0:
+            return
+
+        # Execute ticks
+        for _ in range(num_ticks):
+            self._current_tick += self._config.tick_size
+            await self._execute_tick(processors)
+            self._tick_counter += 1
+
+        # Set final timestamp to exactly match target_time
+        if (
+            abs(self._current_tick - target_time) > 1e-10
+        ):  # Handle floating point precision
+            self._current_tick = target_time
+            await self._execute_tick(processors)
+            self._tick_counter += 1
+
+    async def _execute_tick(self, processors: list[TickProcessor]) -> None:
+        """Execute a tick for all processors."""
+        if self._config.concurrent_processors:
+            # Execute processors concurrently
+            tasks = []
+            for processor in processors:
+                task = asyncio.create_task(
+                    self._execute_processor(processor, self._current_tick)
+                )
+                tasks.append(task)
+
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            errors = []
+
+            # Update states for all processors first
+            for processor, result in zip(processors, results, strict=False):
+                if isinstance(result, Exception):
+                    if self._error_callback:
+                        self._error_callback(processor, result)
+                    errors.append(result)
+                else:
+                    # Update processor state after successful execution
+                    state = self._processor_states[processor]
+                    self._processor_states[processor] = state.model_copy(
+                        update={"last_timestamp": self._current_tick}
+                    )
+
+            # Raise the first error if any occurred
+            if errors:
+                raise errors[0]
+        else:
+            # Execute processors sequentially
+            for processor in processors:
+                try:
+                    await self._execute_processor(processor, self._current_tick)
+                    # Update processor state after successful execution
+                    state = self._processor_states[processor]
+                    self._processor_states[processor] = state.model_copy(
+                        update={"last_timestamp": self._current_tick}
+                    )
+                except Exception as e:
+                    if self._error_callback:
+                        self._error_callback(processor, e)
+                    raise e
+
+    async def fast_forward(self, seconds: float) -> None:
+        """Fast forward the clock by a specified number of seconds."""
+        if not self._current_context:
+            raise ClockError("Fast forward can only be used within a context")
+
+        if seconds <= 0:
+            return
+
+        target_time = self._current_tick + seconds
+        if target_time > self._config.end_time:
+            raise ClockError("Cannot fast forward past end_time in backtest mode")
+
+        await self.run_til(target_time)