trdr 0.0.1__tar.gz

trdr-0.0.1/.github/workflows/publish.yml

@@ -0,0 +1,32 @@
+name: Publish to PyPI
+
+on:
+  push:
+    branches: [ main ]
+
+jobs:
+  pypi-publish:
+    name: upload release to PyPI
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build
+      
+      - name: Build package
+        run: python -m build
+      
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

trdr-0.0.1/.gitignore

@@ -0,0 +1,5 @@
+.venv
+**/__pycache__
+.pytest_cache
+**/.pytest_cache
+**/.DS_Store

trdr-0.0.1/.vscode/extensions.json

@@ -0,0 +1,11 @@
+{
+    "recommendations": [
+        "esbenp.prettier-vscode",
+        "ms-python.black-formatter",
+        "ms-python.python",
+        "github.vscode-github-actions",
+        "pulumi.pulumi-vscode-tools",
+        "ms-python.vscode-pylance",
+        "eamodio.gitlens"
+    ]
+}

trdr-0.0.1/.vscode/launch.json

@@ -0,0 +1,18 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+
+
+        {
+            "name": "Python Debugger: Current File",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal",
+            "cwd": "${workspaceFolder}/examples",
+        }
+    ]
+}

trdr-0.0.1/.vscode/settings.json

@@ -0,0 +1,27 @@
+{
+    "git.enableSmartCommit": true,
+    "git.autofetch": true,
+    "editor.accessibilitySupport": "off",
+    "editor.foldingMaximumRegions": 15000,
+    "editor.formatOnSave": true,
+    "editor.inlineSuggest.enabled": true,
+    "github.copilot.enable": {
+        "*": true
+    },
+    "[python]": {
+        "editor.formatOnSave": true,
+        "editor.defaultFormatter": "ms-python.black-formatter"
+    },
+    "javascript.updateImportsOnFileMove.enabled": "always",
+    "[json]": {
+        "editor.defaultFormatter": "vscode.json-language-features"
+    },
+    "black-formatter.args": [
+        "--line-length=120"
+    ],
+    "python.testing.pytestArgs": [
+        "."
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true,
+}

trdr-0.0.1/CLAUDE.md

@@ -0,0 +1,35 @@
+# TRDR - Trading Framework
+
+## Build & Test Commands
+
+```bash
+# Install dev dependencies
+pip install -e ".[dev]"
+
+# Run all tests
+pytest
+
+# Run specific test file
+pytest src/trdr/path/to/test_file.py
+
+# Run specific test
+pytest src/trdr/path/to/test_file.py::TestClass::test_method
+```
+
+## Code Style Guidelines
+
+- **Naming**: Classes=PascalCase, functions/methods=snake_case, constants=UPPER_SNAKE_CASE
+- **Imports**: Standard lib → third-party → local, specific imports preferred
+- **Types**: Always use type annotations for parameters and return values
+- **Async**: Use async/await pattern with factory `create()` methods
+- **Error handling**: Custom exception hierarchy in each module
+- **Documentation**: Descriptive docstrings for public methods
+- **DSL**: Trading strategies defined in `.trdr` files with STRATEGY, ENTRY, EXIT sections
+- **Async testing**: use asyncio.run() to run async calls in tests
+
+## Project Structure
+
+- `src/trdr/core/`: Core trading components (broker, bar_provider, strategy)
+- `src/trdr/dsl/`: Domain-specific language for strategy definition
+- `src/trdr/conftest.py`: pytest fixtures
+- `src/trdr/test_utils/`: Test utilities

trdr-0.0.1/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: trdr
+Version: 0.0.1
+Summary: Algorithmic trading library
+Author-email: developer_jeb <developer_jeb@outlook.com>
+Requires-Dist: aiohttp==3.11.11
+Requires-Dist: opentelemetry-api==1.30.0
+Requires-Dist: opentelemetry-sdk==1.30.0
+Requires-Dist: pydantic==2.10.6
+Requires-Dist: yfinance==0.2.55
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio==0.25.2; extra == 'dev'
+Requires-Dist: pytest==8.3.4; extra == 'dev'

trdr-0.0.1/README.md

@@ -0,0 +1,190 @@
+# TRDR - Trading Framework
+
+TRDR is a framework for algorithmic trading in Python. It features a custom Domain-Specific Language (DSL) for expressing trading strategies in a clear, concise manner.
+
+## 🌟 Features
+
+- **Custom DSL**: Define trading strategies with a readable, declarative syntax
+- **Modular Architecture**: Easily swap components like brokers and data providers
+- **Async First**: Built from the ground up with Python's async/await pattern
+- **Mock Trading**: Test strategies with a mock broker before using real money
+- **Telemetry Integration**: Optional OpenTelemetry support for performance monitoring
+- **Pattern Day Trading Controls**: Built-in [PDT rule compliance strategies](src/trdr/core/broker/pdt/README.md) (NunStrategy, WiggleStrategy, YoloStrategy)
+
+## 📦 Installation
+
+```bash
+# Basic installation
+pip install trdr
+
+# Development installation (with testing tools)
+pip install -e ".[dev]"
+```
+
+## 🚀 Quick Start
+
+### 1. Define Your Strategy
+
+Create a file `my-strategy.trdr` with your trading strategy:
+
+```
+STRATEGY
+    NAME "Moving Average Crossover"
+    DESCRIPTION "Basic MA crossover strategy with risk management"
+    ENTRY
+        ALL_OF
+            MA5 CROSSED_ABOVE MA20
+            MA20 > MA50
+            CURRENT_PRICE > 100
+    EXIT
+        ANY_OF
+            CURRENT_PRICE > (AVERAGE_COST * 1.06)  # 6% profit target
+            CURRENT_PRICE < (AVERAGE_COST * 0.98)  # 2% stop loss
+    SIZING
+        RULE
+            CONDITION
+                ALL_OF
+                    ACCOUNT_EXPOSURE < 0.5
+                    NUMBER_OF_OPEN_POSITIONS < 3
+            DOLLAR_AMOUNT 
+                (AVAILABLE_CASH * 0.20)
+```
+
+### 2. Run Your Strategy
+
+```python
+import asyncio
+from trdr.core.bar_provider.yf_bar_provider.yf_bar_provider import YFBarProvider
+from trdr.core.security_provider.security_provider import SecurityProvider
+from trdr.core.broker.mock_broker.mock_broker import MockBroker
+from trdr.core.trading_engine.trading_engine import TradingEngine
+from trdr.core.trading_context.trading_context import TradingContext
+from trdr.core.broker.pdt.nun_strategy import NunStrategy
+
+async def main():
+    try:
+        pdt_strategy = NunStrategy.create()
+        async with await MockBroker.create(pdt_strategy=pdt_strategy) as broker:
+            bar_provider = await YFBarProvider.create(["TSLA"])
+            security_provider = await SecurityProvider.create(bar_provider)
+            context = await TradingContext.create(security_provider, broker)
+            engine = await TradingEngine.create("my-strategy", context)
+            await engine.execute()
+    except Exception as e:
+        print(e)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## 🛠️ Architecture
+
+TRDR is built with a modular, component-based architecture:
+
+- **Bar Provider**: Supplies price/volume data (Yahoo Finance implementation included)
+- **Security Provider**: Manages available securities for trading
+- **Broker**: Handles order execution
+  - [Mock Broker](src/trdr/core/broker/mock_broker/) - Local simulation for testing
+  - [Alpaca Broker](src/trdr/core/broker/alpaca_broker/README.md) - Real trading with Alpaca API
+- **Trading Context**: Coordinates components and maintains state
+- **Trading Engine**: Executes strategies using the DSL parser
+- **[PDT Strategies](src/trdr/core/broker/pdt/README.md)**: Enforces Pattern Day Trading rules with multiple compliance strategies
+
+## 📊 DSL Reference
+
+The TRDR Domain Specific Language provides a clean (I hope) syntax for expressing trading logic:
+
+### Strategy Structure
+
+```
+STRATEGY
+    NAME "Strategy Name"
+    DESCRIPTION "Strategy Description"
+    ENTRY
+        # Entry conditions
+    EXIT
+        # Exit conditions
+    SIZING
+        # Position sizing rules
+```
+
+### Logical Operators
+
+```
+ALL_OF          # All conditions must be true
+ANY_OF          # Any condition can be true
+```
+
+### Technical Indicators
+
+```
+MA{period}      # Moving average (e.g., MA5, MA20, MA50, MA100, MA200)
+AV{period}      # Average volume (e.g., AV5, AV20, AV50, AV100, AV200)
+```
+
+### Comparison Operators
+
+```
+>               # Greater than
+<               # Less than
+>=              # Greater than or equal to
+<=              # Less than or equal to
+==              # Equal to
+CROSSED_ABOVE   # Indicator crossed above another
+CROSSED_BELOW   # Indicator crossed below another
+```
+
+### Price Metrics
+
+```
+CURRENT_PRICE   # Current price of the security
+CURRENT_VOLUME  # Current volume of the security
+```
+
+### Account Metrics
+
+```
+ACCOUNT_EXPOSURE         # Percentage of account exposed to market
+AVAILABLE_CASH           # Available cash for trading
+AVERAGE_COST             # Average cost of current position
+NUMBER_OF_OPEN_POSITIONS # Number of currently open positions
+```
+
+### Mathematical Operators
+
+```
++               # Addition
+-               # Subtraction
+*               # Multiplication
+/               # Division
+(expression)    # Parentheses for grouping expressions
+```
+
+## 📚 Examples
+
+Check the `examples/` directory for complete examples:
+
+- **No Telemetry Example**: Basic usage without OpenTelemetry
+- **With Telemetry Example**: Using OpenTelemetry for monitoring
+- **Strategy Examples**: Sample trading strategies
+
+## 🧪 Testing
+
+```bash
+# Run all tests
+pytest
+
+# Run specific test file
+pytest src/trdr/path/to/test_file.py
+
+# Run specific test
+pytest src/trdr/path/to/test_file.py::TestClass::test_method
+```
+
+## 📝 License
+
+[MIT License](LICENSE)
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

trdr-0.0.1/examples/README.md

@@ -0,0 +1,28 @@
+# TRDR Examples
+
+This directory contains examples demonstrating how to use the TRDR trading framework in different scenarios.
+
+## Examples
+
+### No Telemetry
+
+The `no_telemetry` directory demonstrates how to use TRDR without OpenTelemetry integration. This is a simpler setup that doesn't require any tracing infrastructure.
+
+**Key features:**
+- Basic usage with MockBroker
+- No telemetry/tracing configuration
+- Yahoo Finance bar provider for historical data
+
+### With Telemetry
+
+The `with_telemetry` directory shows how to set up TRDR with OpenTelemetry for distributed tracing and monitoring.
+
+**Key features:**
+- OpenTelemetry integration with OTLP exporter
+- MockBroker integration with telemetry
+- Yahoo Finance bar provider for historical data
+- Pattern Day Trading (PDT) strategy integration
+
+## Strategy Examples
+
+The `strategies` directory contains example strategy files in TRDR's domain-specific language (DSL).

trdr-0.0.1/examples/no_telemetry/script.py

@@ -0,0 +1,25 @@
+import asyncio
+
+from trdr.core.bar_provider.yf_bar_provider.yf_bar_provider import YFBarProvider
+from trdr.core.security_provider.security_provider import SecurityProvider
+from trdr.core.broker.mock_broker.mock_broker import MockBroker
+from trdr.core.trading_engine.trading_engine import TradingEngine
+from trdr.core.trading_context.trading_context import TradingContext
+from trdr.core.broker.pdt.nun_strategy import NunStrategy
+
+if __name__ == "__main__":
+
+    async def main():
+        try:
+            pdt_strategy = NunStrategy.create()
+            async with await MockBroker.create(pdt_strategy=pdt_strategy) as broker:
+                bar_provider = await YFBarProvider.create(["TSLA"])
+                security_provider = await SecurityProvider.create(bar_provider)
+                context = await TradingContext.create(security_provider, broker)
+                engine = await TradingEngine.create("first-strat", context, strategies_dir="../strategies")
+                await engine.execute()
+
+        except Exception as e:
+            print(e)
+
+    asyncio.run(main())

trdr-0.0.1/examples/strategies/first-strat.trdr

@@ -0,0 +1,21 @@
+STRATEGY
+    NAME "Basic Strategy"
+    DESCRIPTION "Basic testing strategy"
+    ENTRY
+        ALL_OF
+            MA5 CROSSED_ABOVE MA20
+            MA20 > MA50
+            CURRENT_PRICE > 100
+    EXIT
+        ANY_OF
+            CURRENT_PRICE > (AVERAGE_COST * 1.06)
+            CURRENT_PRICE < (AVERAGE_COST * 0.98)
+    SIZING
+        RULE
+            CONDITION
+                ALL_OF
+                    ACCOUNT_EXPOSURE < 0.5
+                    NUMBER_OF_OPEN_POSITIONS < 3
+            DOLLAR_AMOUNT 
+                (AVAILABLE_CASH * 0.20)
+    

trdr-0.0.1/examples/with_telemetry/script.py

@@ -0,0 +1,40 @@
+import asyncio
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+
+from trdr.core.bar_provider.yf_bar_provider.yf_bar_provider import YFBarProvider
+from trdr.core.security_provider.security_provider import SecurityProvider
+from trdr.core.broker.mock_broker.mock_broker import MockBroker
+from trdr.core.trading_engine.trading_engine import TradingEngine
+from trdr.core.trading_context.trading_context import TradingContext
+from trdr.core.broker.pdt.nun_strategy import NunStrategy
+
+if __name__ == "__main__":
+
+    async def main():
+        tracer_provider = TracerProvider()
+        """
+        I run the collector as a container locally for testing purposes.
+        """
+        otlp_exporter = OTLPSpanExporter(endpoint="localhost:4317", insecure=True)
+        span_processor = BatchSpanProcessor(otlp_exporter, max_export_batch_size=20)
+        tracer_provider.add_span_processor(span_processor)
+        trace.set_tracer_provider(tracer_provider)
+        tracer = trace.get_tracer("trdr")
+        try:
+            pdt_strategy = NunStrategy.create(tracer)
+            async with await MockBroker.create(pdt_strategy, tracer) as broker:
+                bar_provider = await YFBarProvider.create(["TSLA"], tracer)
+                security_provider = await SecurityProvider.create(bar_provider, tracer)
+                context = await TradingContext.create(security_provider, broker, tracer)
+                engine = await TradingEngine.create(
+                    "first-strat", context, strategies_dir="../strategies", tracer=tracer
+                )
+                await engine.execute()
+
+        except Exception as e:
+            print(e)
+
+    asyncio.run(main())

trdr-0.0.1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "trdr"
+version = "0.0.1"
+authors = [
+    { name = "developer_jeb", email = "developer_jeb@outlook.com" },
+]
+description = "Algorithmic trading library"
+dependencies = [
+    "yfinance==0.2.55",
+    "aiohttp==3.11.11",
+    "opentelemetry-api==1.30.0",
+    "opentelemetry-sdk==1.30.0",
+    "pydantic==2.10.6",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest==8.3.4",
+    "pytest-asyncio==0.25.2",
+]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+asyncio_default_fixture_loop_scope = "function"

trdr-0.0.1/src/trdr/conftest.py

@@ -0,0 +1,148 @@
+import asyncio
+import pytest
+import yfinance as yf
+import random
+import datetime
+
+from .core.security_provider.security_provider import SecurityProvider
+from .core.bar_provider.yf_bar_provider.yf_bar_provider import YFBarProvider
+from .test_utils.fake_yf_download import fake_yf_download
+from .test_utils.security_generator import SecurityGenerator, SecurityCriteria
+from .test_utils.position_generator import PositionGenerator, PositionCriteria
+from .test_utils.order_generator import OrderGenerator, OrderCriteria
+from .core.broker.mock_broker.mock_broker import MockBroker
+from .core.broker.pdt.nun_strategy import NunStrategy
+from .core.broker.pdt.wiggle_strategy import WiggleStrategy
+from .core.broker.pdt.yolo_strategy import YoloStrategy
+from .core.trading_context.trading_context import TradingContext
+from .core.shared.models import TradingDateTime
+
+
+@pytest.fixture(scope="function")
+def weekday_trading_datetime():
+    trading_now = TradingDateTime.now()
+    while trading_now.is_weekend:
+        trading_now = trading_now + datetime.timedelta(days=1)
+    return trading_now
+
+
+@pytest.fixture(scope="function")
+def weekend_trading_datetime():
+    trading_now = TradingDateTime.now()
+    while not trading_now.is_weekend:
+        trading_now = trading_now + datetime.timedelta(days=1)
+    return trading_now
+
+
+@pytest.fixture(scope="function")
+def yf_bar_provider_with_fake_data(monkeypatch):
+    monkeypatch.setattr(yf, "download", fake_yf_download)
+    monkeypatch.setattr(yf.shared, "_ERRORS", {"ABCDEFG": "YFTzMissingError()", "AMZN": "JSONDecodeError()"})
+    return asyncio.run(YFBarProvider.create(["AAPL", "MSFT", "ABCDEFG", "AMZN"]))
+
+
+@pytest.fixture(scope="function")
+def security_provider_with_fake_data(yf_bar_provider_with_fake_data):
+    return asyncio.run(SecurityProvider.create(yf_bar_provider_with_fake_data))
+
+
+@pytest.fixture(scope="function")
+def random_security(symbol="AAPL", bar_count=200):
+    """Create a random security with the given symbol and bar count.
+
+    Args:
+        symbol: The ticker symbol to use
+        count: The number of bars to generate
+
+    Returns:
+        A Security instance with randomly generated price and volume data
+    """
+    generator = SecurityGenerator(SecurityCriteria(bar_count=bar_count))
+    security = generator.find_suitable_security()
+    # Override the symbol if requested
+    if symbol != security.symbol:
+        security.symbol = symbol
+    return security
+
+
+@pytest.fixture(scope="function")
+def get_random_security():
+    """Legacy fixture name for backward compatibility."""
+    generator = SecurityGenerator(SecurityCriteria(bar_count=200))
+    return generator.find_suitable_security()
+
+
+@pytest.fixture(scope="module")
+def security_generator():
+    """Return a configured SecurityGenerator instance."""
+    return SecurityGenerator(SecurityCriteria(bar_count=200))
+
+
+@pytest.fixture(scope="function")
+def short_dummy_position():
+    """Create a test position with default values."""
+    position = PositionGenerator(criteria=PositionCriteria(bar_count=1, net_position_bias=0)).generate_positions()[0]
+    return position
+
+
+@pytest.fixture(scope="function")
+def long_dummy_position():
+    """Create a test position with default values."""
+    position = PositionGenerator(criteria=PositionCriteria(bar_count=1, net_position_bias=1)).generate_positions()[0]
+    return position
+
+
+@pytest.fixture(scope="function")
+def dummy_positions():
+    """Create a dictionary of test positions."""
+    num_positions = random.randint(1, 9)
+    positions = PositionGenerator(
+        criteria=PositionCriteria(bar_count=num_positions, net_position_bias=0.5)
+    ).generate_positions()
+    return positions
+
+
+@pytest.fixture(scope="function")
+def mock_broker_with_nun_strategy():
+    nun_strategy = NunStrategy.create()
+    broker = asyncio.run(MockBroker.create(pdt_strategy=nun_strategy))
+    yield broker
+    asyncio.run(broker._session.close())
+
+
+@pytest.fixture(scope="function")
+def mock_broker_with_wiggle_strategy():
+    pdt_strategy = WiggleStrategy.create()
+    pdt_strategy.wiggle_room = 2
+    broker = asyncio.run(MockBroker.create(pdt_strategy=pdt_strategy))
+    yield broker
+    asyncio.run(broker._session.close())
+
+
+@pytest.fixture(scope="function")
+def mock_broker_with_yolo_strategy():
+    pdt_strategy = YoloStrategy.create()
+    broker = asyncio.run(MockBroker.create(pdt_strategy=pdt_strategy))
+    yield broker
+    asyncio.run(broker._session.close())
+
+
+@pytest.fixture(scope="function")
+def mock_trading_context(security_provider_with_fake_data, mock_broker_with_nun_strategy):
+    return asyncio.run(TradingContext.create(security_provider_with_fake_data, mock_broker_with_nun_strategy))
+
+
+@pytest.fixture(scope="function")
+def create_order():
+
+    def _create_order(symbol: str, side=None):
+        return OrderGenerator(criteria=OrderCriteria(count=1, symbol=symbol, side=side)).generate_orders()[0]
+
+    return _create_order
+
+
+@pytest.fixture(scope="function")
+def prepared_trading_context(mock_trading_context: TradingContext):
+    """Prepare trading context with a valid symbol and security."""
+    asyncio.run(mock_trading_context.next_symbol())
+    return mock_trading_context