pineforge-data 0.2.0__py3-none-any.whl

pineforge_data/server_client.py

@@ -0,0 +1,142 @@
+"""Standard-library client for the PineForge FastAPI backtest service."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlsplit
+from urllib.request import Request, urlopen
+from uuid import uuid4
+
+from .backtest import BacktestOptions, JsonValue
+from .models import Bar, Instrument
+
+
+class BacktestServerError(RuntimeError):
+    """The configured FastAPI server rejected or failed a backtest."""
+
+
+def _scalar_inputs(values: Mapping[str, JsonValue] | None, field: str) -> dict[str, object]:
+    result: dict[str, object] = {}
+    for key, value in (values or {}).items():
+        if not isinstance(value, (str, int, float, bool)):
+            raise ValueError(f"{field}.{key} must be a scalar value")
+        result[key] = value
+    return result
+
+
+@dataclass(frozen=True, slots=True)
+class FastApiBacktestClient:
+    """Submit normalized bars to a bounded remote PineForge runtime."""
+
+    base_url: str
+    timeout_seconds: float = 330.0
+    api_key: str | None = None
+    max_response_bytes: int = 128 * 1_024 * 1_024
+
+    def __post_init__(self) -> None:
+        parsed = urlsplit(self.base_url)
+        if parsed.scheme not in ("http", "https") or not parsed.netloc:
+            raise ValueError("server URL must be an absolute http:// or https:// URL")
+        if self.timeout_seconds <= 0 or self.max_response_bytes <= 0:
+            raise ValueError("client timeout and response limit must be positive")
+
+    def run(
+        self,
+        pine_source: str,
+        bars: Sequence[Bar],
+        *,
+        instrument: Instrument,
+        source: str,
+        options: BacktestOptions,
+        strategy_params: Mapping[str, JsonValue] | None = None,
+        strategy_overrides: Mapping[str, JsonValue] | None = None,
+    ) -> dict[str, object]:
+        payload = {
+            "pine_source": pine_source,
+            "bars": [
+                {
+                    "timestamp_ms": bar.timestamp_ms,
+                    "open": bar.open,
+                    "high": bar.high,
+                    "low": bar.low,
+                    "close": bar.close,
+                    "volume": bar.volume,
+                }
+                for bar in bars
+            ],
+            "instrument": {
+                "symbol": instrument.symbol,
+                "venue": instrument.venue,
+                "timezone": instrument.timezone,
+                "session": instrument.session,
+                "volume_unit": instrument.volume_unit,
+            },
+            "source": source,
+            "options": {
+                "input_timeframe": options.input_timeframe,
+                "script_timeframe": options.script_timeframe,
+                "bar_magnifier": options.bar_magnifier,
+                "magnifier_samples": options.magnifier_samples,
+                "magnifier_distribution": options.magnifier_distribution.name.lower(),
+                "trace_enabled": options.trace_enabled,
+                "chart_timezone": options.chart_timezone,
+                "trade_start_time_ms": options.trade_start_time_ms,
+            },
+            "strategy_params": _scalar_inputs(strategy_params, "strategy_params"),
+            "strategy_overrides": _scalar_inputs(strategy_overrides, "strategy_overrides"),
+        }
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "X-Request-ID": uuid4().hex,
+        }
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        request = Request(
+            f"{self.base_url.rstrip('/')}/v1/backtests",
+            data=json.dumps(payload, separators=(",", ":"), allow_nan=False).encode(),
+            headers=headers,
+            method="POST",
+        )
+        try:
+            with urlopen(request, timeout=self.timeout_seconds) as response:
+                body = response.read(self.max_response_bytes + 1)
+        except HTTPError as exc:
+            body = exc.read(self.max_response_bytes + 1)
+            detail = _error_message(body) or f"HTTP {exc.code}"
+            raise BacktestServerError(detail) from exc
+        except URLError as exc:
+            raise BacktestServerError(f"backtest server is unavailable: {exc.reason}") from exc
+        if len(body) > self.max_response_bytes:
+            raise BacktestServerError("backtest server response exceeded the configured limit")
+        try:
+            value = json.loads(body)
+        except json.JSONDecodeError as exc:
+            raise BacktestServerError("backtest server returned invalid JSON") from exc
+        if not isinstance(value, dict):
+            raise BacktestServerError("backtest server response must be a JSON object")
+        if value.get("schema_version") != 1:
+            raise BacktestServerError("unsupported backtest server response schema")
+        if not isinstance(value.get("runtime"), dict) or not isinstance(
+            value.get("backtest"), dict
+        ):
+            raise BacktestServerError("backtest server response is missing runtime data")
+        return value
+
+
+def _error_message(body: bytes) -> str:
+    try:
+        value = json.loads(body)
+    except json.JSONDecodeError:
+        return body.decode("utf-8", "replace").strip()
+    if not isinstance(value, dict) or not isinstance(value.get("error"), dict):
+        return str(value)
+    error = value["error"]
+    phase = error.get("phase", "server")
+    message = error.get("message", "request failed")
+    request_id = error.get("request_id")
+    suffix = f" (request {request_id})" if request_id else ""
+    return f"{phase}: {message}{suffix}"

pineforge_data-0.2.0.dist-info/METADATA

@@ -0,0 +1,364 @@
+Metadata-Version: 2.4
+Name: pineforge-data
+Version: 0.2.0
+Summary: Provider-neutral market and macro data adapters for PineForge
+Project-URL: Homepage, https://github.com/pineforge-4pass/pineforge-data
+Project-URL: Documentation, https://pineforge-4pass.github.io/pineforge-data/
+Project-URL: Issues, https://github.com/pineforge-4pass/pineforge-data/issues
+Project-URL: Source, https://github.com/pineforge-4pass/pineforge-data
+Author: PineForge contributors
+License: Apache-2.0
+License-File: LICENSE
+Keywords: backtesting,macro-data,market-data,pinescript
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Provides-Extra: ccxt
+Requires-Dist: ccxt<5,>=4.5.64; extra == 'ccxt'
+Provides-Extra: database
+Requires-Dist: sqlalchemy<3,>=2.0; extra == 'database'
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: fastapi<0.140,>=0.139; extra == 'dev'
+Requires-Dist: httpx2<2.6,>=2.5; extra == 'dev'
+Requires-Dist: mypy>=1.13; extra == 'dev'
+Requires-Dist: pytest>=8.3; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Requires-Dist: sqlalchemy<3,>=2.0; extra == 'dev'
+Requires-Dist: uvicorn<0.52,>=0.51; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material<10,>=9.7; extra == 'docs'
+Requires-Dist: mkdocs<2,>=1.6; extra == 'docs'
+Requires-Dist: mkdocstrings-python<3,>=2.0; extra == 'docs'
+Requires-Dist: ruff>=0.8; extra == 'docs'
+Provides-Extra: release
+Requires-Dist: build<2,>=1.2; extra == 'release'
+Requires-Dist: twine<7,>=6.2; extra == 'release'
+Provides-Extra: server
+Requires-Dist: fastapi<0.140,>=0.139; extra == 'server'
+Requires-Dist: uvicorn<0.52,>=0.51; extra == 'server'
+Description-Content-Type: text/markdown
+
+# PineForge Data
+
+Provider-neutral market and macro data adapters for PineForge.
+
+`pineforge-data` is the boundary between third-party services and the
+deterministic [`pineforge-engine`](https://github.com/pineforge-4pass/pineforge-engine)
+runtime:
+
+```text
+provider APIs → pineforge-data normalization → PineForge C ABI
+```
+
+The engine does not import or link this package. Provider transport,
+authentication, retries, caching, symbol mapping, and vendor schemas stay here;
+the engine receives only normalized bars and ordered trades.
+
+## Documentation
+
+- [Documentation home](https://pineforge-4pass.github.io/pineforge-data/) — architecture, guarantees, and guide map.
+- [Getting started](https://pineforge-4pass.github.io/pineforge-data/getting-started/) — installation, first provider
+  request, and local or remote backtest.
+- [Python API reference](https://pineforge-4pass.github.io/pineforge-data/api/) — generated signatures, types, and docstrings.
+- [Normalized data model](https://pineforge-4pass.github.io/pineforge-data/data-model/) — instruments, contracts, bars,
+  live trades, macro vintages, and validation rules.
+- [Provider catalog](https://pineforge-4pass.github.io/pineforge-data/providers/) — shared lifecycle and second-level API
+  guides for CCXT, CSV, SQLite, and SQLAlchemy.
+- [Backtesting](https://pineforge-4pass.github.io/pineforge-data/backtesting/) — CLI options, configuration files, runtime
+  channels, report schema, and reproducibility.
+- [FastAPI server](https://pineforge-4pass.github.io/pineforge-data/server/) — concurrency, authentication, timeouts,
+  compile cache, and deployment.
+- [Provider contract](https://pineforge-4pass.github.io/pineforge-data/provider-contract/) — implementing and testing a
+  community exchange or broker adapter.
+
+## Why Python first
+
+Provider integrations are dominated by HTTP, WebSockets, JSON, credentials,
+and asynchronous I/O. Python makes those integrations accessible to community
+contributors. Engine throughput remains native: normalized records are packed
+into contiguous C ABI arrays and submitted in one call.
+
+## Initial contracts
+
+- `Instrument` — normalized symbol, provider-native ID, venue, asset/market type,
+  currencies, contract terms, timezone, session, and volume units.
+- `MarketListing` and `MarketQuery` — catalog discovery without vendor schemas.
+- `Bar` — confirmed OHLCV with source provenance.
+- `TradeTick` — the provider-neutral four-field engine payload plus provenance.
+- `MacroObservation` — observation period, first release, and vintage timestamps
+  to prevent revised-data lookahead.
+- `MarketCatalogProvider`, `HistoricalBarProvider`, `LiveTradeProvider`, and
+  `MacroDataProvider` — small structural protocols that community adapters
+  implement.
+- `ProviderRegistry` — built-in and installed broker adapters selected by name.
+- `BarColumnMapping` and `TabularSchema` — runtime discovery and safe OHLCV
+  mappings for user-owned files, tables, and views.
+- `PfBar`, `PfTradeTick`, and `EngineStreamSink` — dependency-free `ctypes`
+  interoperability with PineForge strategy libraries.
+
+## CCXT adapter
+
+The first community adapter uses CCXT's unified async API for exchange-neutral
+crypto data. It paginates OHLCV, removes duplicate timestamps, excludes the
+currently forming candle, and polls public trades into a strictly increasing
+per-stream sequence.
+
+```bash
+pip install 'pineforge-data[ccxt]'
+```
+
+```python
+from pineforge_data import BarRequest, CcxtProvider, Instrument
+
+instrument = Instrument("BTC/USDT", venue="kraken")
+request = BarRequest(
+    instrument,
+    timeframe="1m",
+    start_ms=1_767_225_600_000,
+    end_ms=1_767_312_000_000,
+)
+
+async with CcxtProvider("kraken") as provider:
+    listing = await provider.resolve_market("BTC/USDT")
+    confirmed_bars = await provider.fetch_bars(request)
+```
+
+`Instrument.symbol` uses CCXT's exact unified spelling. Do not infer a market
+by parsing it: `resolve_market()` uses CCXT's catalog fields to distinguish
+spot, swap, future, and option listings and captures `base`, `quote`, `settle`,
+raw exchange ID, contract size, linear/inverse settlement, expiry, strike, and
+option type. For example, `BTC/USDT` and `BTC/USDT:USDT` are separate markets.
+
+Exchange credentials and exchange-specific options can be passed through
+`config`, while endpoint options remain isolated in `market_params`,
+`ohlcv_params`, and `trade_params`. Realtime public trades use REST polling in
+this bootstrap; a WebSocket transport can implement the same
+`LiveTradeProvider` contract later.
+
+`TradeSubscription.start_ms` can pin the live handoff to the next timestamp
+after an engine warmup. `start_sequence` is the last accepted sequence, so the
+adapter emits `start_sequence + 1` next.
+
+## Local files and databases
+
+Built-in `csv`, `sqlite`, and `sqlalchemy` providers let users backtest their
+own data without adopting a fixed PineForge DDL. They inspect file headers or
+database reflection metadata at runtime, infer common OHLCV names, and accept
+partial mappings for arbitrary names. Ambiguous schemas fail instead of being
+guessed.
+
+```python
+from pineforge_data import SqliteBarProvider
+
+
+provider = SqliteBarProvider(
+    "warehouse.sqlite3",
+    table="price candles",
+    mapping={
+        "timestamp": "epoch seconds",
+        "open": "first px",
+        "high": "top px",
+        "low": "bottom px",
+        "close": "last px",
+        "volume": "traded qty",
+    },
+    timestamp_unit="seconds",
+)
+schema = await provider.inspect_schema()
+```
+
+SQL identifiers are validated against reflected metadata; filter values are
+bound parameters. For complex transformations, expose a database view rather
+than putting raw SQL in harness configuration. See the complete
+[provider catalog](https://pineforge-4pass.github.io/pineforge-data/providers/),
+with dedicated API guides for
+[CSV](https://pineforge-4pass.github.io/pineforge-data/providers/csv/),
+[SQLite](https://pineforge-4pass.github.io/pineforge-data/providers/sqlite/), and
+[SQLAlchemy](https://pineforge-4pass.github.io/pineforge-data/providers/sqlalchemy/).
+
+## Direct backtest harness
+
+The public backtest input is raw PineScript v6. `pineforge-backtest` fetches
+confirmed OHLCV through a data provider and runs this pinned pipeline:
+
+```text
+raw .pine + provider OHLCV
+        ↓ local read-only mount or FastAPI request
+pineforge-release → generated C++ → cached/compiled strategy → JSON report
+```
+
+Docker is a prerequisite. A host C++ compiler and a precompiled strategy
+library are not required. Install the package without cloning engine or codegen
+repositories:
+
+```bash
+pip install 'pineforge-data[ccxt]'
+```
+
+```bash
+pineforge-backtest \
+  --pine strategy.pine \
+  --provider ccxt \
+  --venue kraken \
+  --symbol BTC/USD \
+  --timeframe 15m \
+  --start 2026-07-01T00:00:00Z \
+  --end 2026-07-08T00:00:00Z \
+  --warmup-bars 500 \
+  --output report.json \
+  --pretty
+```
+
+`--warmup-bars` fetches additional source bars before `--start` to initialize
+indicators and higher-timeframe state. Order execution remains disabled until
+`--start`, and the report records both requested and loaded warmup counts.
+
+The first local invocation pulls an immutable, multi-architecture
+`pineforge-release` image pinned by both version and OCI digest. It never builds
+engine or codegen locally. Use `--pull-policy never` for offline runs or opt in
+to the rolling channel with:
+
+```bash
+pineforge-backtest ... \
+  --runtime-image ghcr.io/pineforge-4pass/pineforge-release:latest \
+  --pull-policy always
+```
+
+`latest` is convenient for development but not deterministic. The report
+records the resolved image digest and component versions when Docker exposes
+them.
+
+Compilation and execution run as a non-root user with networking disabled, all
+Linux capabilities dropped, a read-only root filesystem, and only a read-only
+temporary input mount.
+
+The JSON report contains provider and market provenance, the release runtime
+identity and fingerprint, processed-bar counts, every closed trade,
+all/long/short statistics, equity statistics, diagnostics, and the complete
+equity curve. Unix millisecond timestamps can be used instead of ISO-8601
+values. The pinned `pineforge-release` does not currently expose trace
+collection; `--trace` fails explicitly rather than silently omitting it.
+
+Use `--provider-config config.json` for CCXT constructor options and
+`--strategy-params inputs.json` for Pine inputs. Use `--strategy-overrides` for
+`strategy()` header overrides. The provider config file may contain
+credentials, so keep it outside version control.
+
+The generated C++ hash and exact engine/codegen versions are recorded in the
+release fingerprint. The combined runtime and its component licensing are
+owned by [`pineforge-release`](https://github.com/pineforge-4pass/pineforge-release),
+not vendored into this repository.
+
+Provider implementations in this repository are Python-only. The compiled C++
+strategy and engine stay behind the Docker/runtime boundary; broker SDKs and
+provider-specific types do not cross into `pineforge-engine`.
+
+## Concurrent FastAPI server
+
+The server image derives from the same pinned `pineforge-release` image. It
+admits a bounded number of compiler/backtest processes, keeps a bounded queue,
+isolates every request in its own temporary directory, and optionally requires
+a bearer token.
+
+```bash
+docker build -f docker/server.Dockerfile -t pineforge-data-server .
+docker volume create pineforge-compile-cache
+docker run --rm -p 127.0.0.1:8000:8000 \
+  --read-only \
+  --tmpfs /tmp:rw,exec,nosuid,nodev,size=512m \
+  --cap-drop ALL \
+  --security-opt no-new-privileges \
+  --mount type=volume,src=pineforge-compile-cache,dst=/cache \
+  -e PINEFORGE_SERVER_API_KEY=change-me \
+  pineforge-data-server
+```
+
+Point the same harness at it without putting the token on the command line:
+
+```bash
+export PINEFORGE_SERVER_URL=http://127.0.0.1:8000
+export PINEFORGE_SERVER_API_KEY=change-me
+pineforge-backtest --pine strategy.pine --venue kraken --symbol BTC/USD \
+  --timeframe 15m --start 2026-07-01T00:00:00Z --end 2026-07-08T00:00:00Z
+```
+
+The server always transpiles Pine deterministically and hashes the generated
+C++. Its cache stores the compiled `.so` under a key containing that C++ hash
+plus the release, engine, architecture, and compile flags. Concurrent misses
+for the same key compile once; subsequent requests skip compilation. Cache
+hit/key/hash are included in response provenance. See the
+[server guide](https://pineforge-4pass.github.io/pineforge-data/server/) for endpoints, limits, deployment, and cache
+settings.
+
+## Contributing
+
+Community providers, market-model improvements, server/runtime work, tests, and
+documentation are welcome. Provider integrations are Python-only; engine and
+codegen changes belong in their upstream repositories and are consumed here
+through `pineforge-release`.
+
+### Choose the right contribution path
+
+| Contribution | Primary location | Start here |
+|---|---|---|
+| Exchange or broker adapter | `src/pineforge_data/providers/` | [Provider contract](https://pineforge-4pass.github.io/pineforge-data/provider-contract/) |
+| Market, contract, bar, or request model | `src/pineforge_data/models.py`, `src/pineforge_data/requests.py`, `src/pineforge_data/providers/base.py` | Existing public models and protocols |
+| Backtest harness or HTTP client | `src/pineforge_data/cli/backtest.py`, `src/pineforge_data/server_client.py` | Harness unit tests |
+| FastAPI concurrency or compile cache | `src/pineforge_data/server.py`, `src/pineforge_data/compile_cache.py` | [Server guide](https://pineforge-4pass.github.io/pineforge-data/server/) |
+| Release-container integration | `src/pineforge_data/release_contract.py`, `src/pineforge_data/docker_runtime.py` | Pinned release contract and Docker tests |
+| Documentation or examples | `README.md`, `docs/` | A focused documentation PR |
+
+For a new provider, implement the smallest applicable structural protocols,
+register its factory, keep its SDK in an optional dependency extra, and add
+offline fixture tests. Resolve exact upstream markets through their catalog;
+do not parse symbols to infer base, quote, settlement, or contract terms.
+Provider-specific fields stay in this repository and must not leak into
+`pineforge-engine`.
+
+### Development setup
+
+```bash
+git clone https://github.com/pineforge-4pass/pineforge-data.git
+cd pineforge-data
+python3 -m venv .venv
+.venv/bin/pip install -e '.[dev,ccxt,server]'
+```
+
+No Git submodules are required. Docker is needed only for release-runtime and
+end-to-end backtest work.
+
+### Before opening a pull request
+
+1. Keep the change focused and document any public API, report-schema, provider,
+   runtime-image, or cache-key compatibility impact.
+2. Add deterministic offline tests; CI must not require credentials or live
+   provider access.
+3. Keep credentials out of fixtures, logs, exception messages, and committed
+   configuration.
+4. Run the standard checks:
+
+   ```bash
+   .venv/bin/ruff format --check src tests
+   .venv/bin/ruff check .
+   .venv/bin/mypy src
+   .venv/bin/pytest
+   .venv/bin/python -m build
+   ```
+
+5. For Docker, FastAPI server, cache, or release-contract changes, also run:
+
+   ```bash
+   PINEFORGE_DOCKER_TEST=1 .venv/bin/pytest tests/test_docker_integration.py
+   ```
+
+Read the [documentation home](https://pineforge-4pass.github.io/pineforge-data/)
+and [CONTRIBUTING.md](https://github.com/pineforge-4pass/pineforge-data/blob/main/CONTRIBUTING.md) for provider requirements,
+determinism rules, external provider entry points, and the complete checklist.
+For broad changes to public models or the report contract, open an issue first
+so providers and runtime consumers can agree on the shape before implementation.

pineforge_data-0.2.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+pineforge_data/__init__.py,sha256=__cVJ5xJIbGQfSmFxBApC9OkSuiMXnkPPZPCu1lRo5U,2991
+pineforge_data/backtest.py,sha256=XEuTzE7gSmJGKG_AgC1kB_pGblcwxf2PFIFAkpVTdOQ,21119
+pineforge_data/compile_cache.py,sha256=47x-H618QesZhDLghxHM2-dXTGNm5W19izTElYvaA0w,5645
+pineforge_data/docker_runtime.py,sha256=ggMpNXhqZ4M_lvAAXYvY4NtriAP1I-g89lEGUTx-ZEg,7859
+pineforge_data/engine.py,sha256=djCqdyEYbjrbi7eK6dKmTvLhajI8OQThJbsx8RW9Qxo,6721
+pineforge_data/errors.py,sha256=qGT66oufMrj_a_aHIL4mv5t3XK5yvFo9RWH4MndUi0w,153
+pineforge_data/models.py,sha256=X5I818hS68SEkTG-q9uU2qdc9UJGXWhOzXDIppFeCkI,6279
+pineforge_data/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pineforge_data/release_contract.py,sha256=wEflU-605RsdNgVI5UaTB1kAIngXX7b-lEA1MmPaOZM,5538
+pineforge_data/requests.py,sha256=iX7wEiKMLU3dfwTOZqXoFVIjP_qf3k1V8PJB9GQOat0,3197
+pineforge_data/server.py,sha256=id48AtB9rn_qT7AlCtcjP-hnTnXG4mUs2ZDdv3-wX8Q,23701
+pineforge_data/server_client.py,sha256=weJnFdoeEM5y81tlJejtP_hWNru6J7bS9fsLdrTr-ls,5708
+pineforge_data/cli/__init__.py,sha256=lCHfy77tj8312uwexeJG6-fJYlqY2gDkn4P5knKPgiI,58
+pineforge_data/cli/backtest.py,sha256=-voKKnDPAdhiGNuFbI8vsm1lH8_VS5eE3lXkFa1y8Wg,13388
+pineforge_data/providers/__init__.py,sha256=bdIdX0vAh4OInYBz19xHF5tg-zS_oJnjZhPtw-veLW8,1566
+pineforge_data/providers/base.py,sha256=Oo_FImXWG6epF1dcyQCmlfXbPCQlT3PXEbZmscjKK8o,1430
+pineforge_data/providers/ccxt.py,sha256=XVM5eAEgiEmcspw958tOAQ8_8HkG8URfNkdu-duykUE,15552
+pineforge_data/providers/local.py,sha256=AiMHWI5RHm3wo-TQod7c8T8KABirLood9S0IrTEcxLY,7743
+pineforge_data/providers/registry.py,sha256=A7Bip2jE7Hrr4uwG9Vuu_J903RaadLrimv32KO2MrYo,9565
+pineforge_data/providers/sqlalchemy.py,sha256=1m8huLOMm_kxTVLZutwU2qnTBCZmDLGotWMcjGouuic,5081
+pineforge_data/providers/tabular.py,sha256=1NjPy99Qly1PTGeLVYkVbH7jVo1kmwPMmkeICQGWDQ4,20813
+pineforge_data-0.2.0.dist-info/METADATA,sha256=K6hPhQYVodRHbx8i9fLxj-oqwSNWTyb2p1dS_cA61cY,15750
+pineforge_data-0.2.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+pineforge_data-0.2.0.dist-info/entry_points.txt,sha256=ecEJlP8Fd9hEH5kWhmpiBOqzm9Wu7gffn6oPrxyIdsQ,127
+pineforge_data-0.2.0.dist-info/licenses/LICENSE,sha256=e48PSlRg3fD_D7eYddPiSQd1AWenf1AuQ149pF6sUrg,11352
+pineforge_data-0.2.0.dist-info/RECORD,,

pineforge_data-0.2.0.dist-info/WHEEL

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

pineforge_data-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pineforge-backtest = pineforge_data.cli.backtest:main
+pineforge-backtest-server = pineforge_data.server:main