pnf-chart-system 0.1.1__tar.gz

pnf_chart_system-0.1.1/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include VERSION
+include pypnf_dashboard.py

pnf_chart_system-0.1.1/PKG-INFO

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: pnf-chart-system
+Version: 0.1.1
+Summary: Point and Figure Chart Library - Python bindings
+Home-page: https://github.com/gregorian-09/pnf-chart-system
+Author: Gregorian Rayne
+Author-email: gregorianrayne09@gmail.com
+Project-URL: Documentation, https://github.com/gregorian-09/pnf-chart-system/tree/master/docs
+Project-URL: API Reference, https://github.com/gregorian-09/pnf-chart-system/blob/master/docs/bindings/python.md
+Project-URL: Changelog, https://github.com/gregorian-09/pnf-chart-system/blob/master/CHANGELOG.md
+Project-URL: Issues, https://github.com/gregorian-09/pnf-chart-system/issues
+Project-URL: Source, https://github.com/gregorian-09/pnf-chart-system
+Keywords: point-and-figure,charting,technical-analysis,trading,indicators
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+# pnf-chart-system
+
+[![PyPI version](https://img.shields.io/pypi/v/pnf-chart-system.svg)](https://pypi.org/project/pnf-chart-system/)
+[![Python versions](https://img.shields.io/pypi/pyversions/pnf-chart-system.svg)](https://pypi.org/project/pnf-chart-system/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/gregorian-09/pnf-chart-system/blob/master/LICENSE)
+
+Production-ready Python bindings for the PnF (Point and Figure) engine.
+
+Package name is `pnf-chart-system`; import name is `pypnf`.
+
+## Why This Package
+
+`pypnf` is built for real analysis workflows, not only chart construction:
+
+| Area | What you get |
+| --- | --- |
+| Chart Engine | Point-and-Figure charting with `Close` and `HighLow` construction |
+| Trend Context | Bullish support / bearish resistance context checks |
+| Indicators | SMA, Bollinger Bands, RSI, OBV, Bullish Percent |
+| Structural Signals | Buy/sell signals and full PnF pattern detection |
+| Market Structure | Support/resistance levels, price objectives, congestion zones |
+| Visualization | Localhost real-time dashboard streaming |
+
+## Installation
+
+```bash
+pip install pnf-chart-system
+```
+
+## Quick Start
+
+```python
+import pypnf
+
+cfg = pypnf.ChartConfig()
+cfg.method = pypnf.ConstructionMethod.HighLow
+cfg.box_size_method = pypnf.BoxSizeMethod.Traditional
+cfg.box_size = 0.0
+cfg.reversal = 3
+
+chart = pypnf.Chart(cfg)
+
+# high, low, close, timestamp
+chart.add_data(5000.0, 4950.0, 4985.0, 1700000000)
+chart.add_data(5040.0, 4980.0, 5030.0, 1700003600)
+chart.add_data(5065.0, 5010.0, 5055.0, 1700007200)
+
+indicators = pypnf.Indicators(pypnf.IndicatorConfig())
+indicators.calculate(chart)
+
+print(chart.to_ascii())
+print(indicators.summary())
+```
+
+## Trendline and Bias Workflow
+
+```python
+last_price = 5055.0
+
+print("Bullish bias:", chart.has_bullish_bias())
+print("Bearish bias:", chart.has_bearish_bias())
+print("Above bullish support:", chart.is_above_bullish_support(last_price))
+print("Below bearish resistance:", chart.is_below_bearish_resistance(last_price))
+```
+
+These checks are the normal first gate before acting on breakout or breakdown patterns.
+
+## Indicators and Momentum
+
+```python
+indicators.calculate(chart)
+
+sma_short = indicators.sma_short()
+bands = indicators.bollinger()
+rsi = indicators.rsi()
+obv = indicators.obv()
+
+col = chart.column_count() - 1
+if col >= 0:
+    print("SMA short:", sma_short.value(col))
+    print("Bollinger upper:", bands.upper(col))
+    print("RSI:", rsi.value(col))
+    print("OBV:", obv.value(col))
+```
+
+## Signals and Pattern Detection
+
+```python
+signals = indicators.signals()
+patterns = indicators.patterns()
+
+print("Current signal:", signals.current_signal())
+print("Buy count:", signals.buy_count())
+print("Sell count:", signals.sell_count())
+
+print("Pattern count:", patterns.pattern_count())
+print("Bullish patterns:", len(patterns.bullish_patterns()))
+print("Bearish patterns:", len(patterns.bearish_patterns()))
+```
+
+## Support, Resistance, Objectives, Congestion
+
+```python
+sr = indicators.support_resistance()
+obj = indicators.objectives()
+cong = indicators.congestion()
+
+print("Support levels:", sr.support_levels())
+print("Resistance levels:", sr.resistance_levels())
+print("Significant levels (>=3 touches):", sr.significant_levels(3))
+
+print("Bullish targets:", obj.bullish_targets())
+print("Bearish targets:", obj.bearish_targets())
+
+print("Congestion zones:", cong.zones())
+```
+
+## Real-Time Dashboard
+
+```python
+from pypnf_dashboard import DashboardServer
+
+server = DashboardServer(chart, indicators)
+server.start("127.0.0.1", 8761)
+server.publish()
+print(server.url())
+```
+
+You can call `server.publish()` after each new bar/tick batch to keep the browser in sync.
+
+## API Map
+
+Core:
+- `Chart`, `ChartConfig`, `Box`, `Column`
+
+Indicators:
+- `Indicators`, `IndicatorConfig`
+- `MovingAverage`, `BollingerBands`, `RSI`, `OnBalanceVolume`, `BullishPercent`
+- `SignalDetector`, `PatternRecognizer`, `SupportResistance`, `PriceObjectiveCalculator`, `CongestionDetector`
+
+Data:
+- `OHLC`, `Signal`, `Pattern`, `SupportResistanceLevel`, `PriceObjective`, `CongestionZone`
+
+Enums:
+- `BoxType`, `ColumnType`, `ConstructionMethod`, `BoxSizeMethod`, `SignalType`, `PatternType`
+
+## Versioning and Compatibility
+
+- Python package version tracks the same release as the core engine.
+- Keep all bindings on the same version when mixing languages in one system.
+- See `CHANGELOG.md` for version-by-version behavior changes.
+
+## Troubleshooting
+
+- `ImportError` / native load issues: rebuild and ensure the native library is discoverable.
+- Empty indicator values: verify you have enough columns for the configured lookback periods.
+- Unexpected chart shape: ensure `HighLow` mode receives real high/low values, not close-only values.
+
+## Documentation and Links
+
+- Python API reference: `docs/bindings/python.md`
+- Cross-language API index: `docs/reference/api-symbol-index.md`
+- Source: https://github.com/gregorian-09/pnf-chart-system
+- Issues: https://github.com/gregorian-09/pnf-chart-system/issues
+- Changelog: https://github.com/gregorian-09/pnf-chart-system/blob/master/CHANGELOG.md

pnf_chart_system-0.1.1/README.md

@@ -0,0 +1,165 @@
+# pnf-chart-system
+
+[![PyPI version](https://img.shields.io/pypi/v/pnf-chart-system.svg)](https://pypi.org/project/pnf-chart-system/)
+[![Python versions](https://img.shields.io/pypi/pyversions/pnf-chart-system.svg)](https://pypi.org/project/pnf-chart-system/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/gregorian-09/pnf-chart-system/blob/master/LICENSE)
+
+Production-ready Python bindings for the PnF (Point and Figure) engine.
+
+Package name is `pnf-chart-system`; import name is `pypnf`.
+
+## Why This Package
+
+`pypnf` is built for real analysis workflows, not only chart construction:
+
+| Area | What you get |
+| --- | --- |
+| Chart Engine | Point-and-Figure charting with `Close` and `HighLow` construction |
+| Trend Context | Bullish support / bearish resistance context checks |
+| Indicators | SMA, Bollinger Bands, RSI, OBV, Bullish Percent |
+| Structural Signals | Buy/sell signals and full PnF pattern detection |
+| Market Structure | Support/resistance levels, price objectives, congestion zones |
+| Visualization | Localhost real-time dashboard streaming |
+
+## Installation
+
+```bash
+pip install pnf-chart-system
+```
+
+## Quick Start
+
+```python
+import pypnf
+
+cfg = pypnf.ChartConfig()
+cfg.method = pypnf.ConstructionMethod.HighLow
+cfg.box_size_method = pypnf.BoxSizeMethod.Traditional
+cfg.box_size = 0.0
+cfg.reversal = 3
+
+chart = pypnf.Chart(cfg)
+
+# high, low, close, timestamp
+chart.add_data(5000.0, 4950.0, 4985.0, 1700000000)
+chart.add_data(5040.0, 4980.0, 5030.0, 1700003600)
+chart.add_data(5065.0, 5010.0, 5055.0, 1700007200)
+
+indicators = pypnf.Indicators(pypnf.IndicatorConfig())
+indicators.calculate(chart)
+
+print(chart.to_ascii())
+print(indicators.summary())
+```
+
+## Trendline and Bias Workflow
+
+```python
+last_price = 5055.0
+
+print("Bullish bias:", chart.has_bullish_bias())
+print("Bearish bias:", chart.has_bearish_bias())
+print("Above bullish support:", chart.is_above_bullish_support(last_price))
+print("Below bearish resistance:", chart.is_below_bearish_resistance(last_price))
+```
+
+These checks are the normal first gate before acting on breakout or breakdown patterns.
+
+## Indicators and Momentum
+
+```python
+indicators.calculate(chart)
+
+sma_short = indicators.sma_short()
+bands = indicators.bollinger()
+rsi = indicators.rsi()
+obv = indicators.obv()
+
+col = chart.column_count() - 1
+if col >= 0:
+    print("SMA short:", sma_short.value(col))
+    print("Bollinger upper:", bands.upper(col))
+    print("RSI:", rsi.value(col))
+    print("OBV:", obv.value(col))
+```
+
+## Signals and Pattern Detection
+
+```python
+signals = indicators.signals()
+patterns = indicators.patterns()
+
+print("Current signal:", signals.current_signal())
+print("Buy count:", signals.buy_count())
+print("Sell count:", signals.sell_count())
+
+print("Pattern count:", patterns.pattern_count())
+print("Bullish patterns:", len(patterns.bullish_patterns()))
+print("Bearish patterns:", len(patterns.bearish_patterns()))
+```
+
+## Support, Resistance, Objectives, Congestion
+
+```python
+sr = indicators.support_resistance()
+obj = indicators.objectives()
+cong = indicators.congestion()
+
+print("Support levels:", sr.support_levels())
+print("Resistance levels:", sr.resistance_levels())
+print("Significant levels (>=3 touches):", sr.significant_levels(3))
+
+print("Bullish targets:", obj.bullish_targets())
+print("Bearish targets:", obj.bearish_targets())
+
+print("Congestion zones:", cong.zones())
+```
+
+## Real-Time Dashboard
+
+```python
+from pypnf_dashboard import DashboardServer
+
+server = DashboardServer(chart, indicators)
+server.start("127.0.0.1", 8761)
+server.publish()
+print(server.url())
+```
+
+You can call `server.publish()` after each new bar/tick batch to keep the browser in sync.
+
+## API Map
+
+Core:
+- `Chart`, `ChartConfig`, `Box`, `Column`
+
+Indicators:
+- `Indicators`, `IndicatorConfig`
+- `MovingAverage`, `BollingerBands`, `RSI`, `OnBalanceVolume`, `BullishPercent`
+- `SignalDetector`, `PatternRecognizer`, `SupportResistance`, `PriceObjectiveCalculator`, `CongestionDetector`
+
+Data:
+- `OHLC`, `Signal`, `Pattern`, `SupportResistanceLevel`, `PriceObjective`, `CongestionZone`
+
+Enums:
+- `BoxType`, `ColumnType`, `ConstructionMethod`, `BoxSizeMethod`, `SignalType`, `PatternType`
+
+## Versioning and Compatibility
+
+- Python package version tracks the same release as the core engine.
+- Keep all bindings on the same version when mixing languages in one system.
+- See `CHANGELOG.md` for version-by-version behavior changes.
+
+## Troubleshooting
+
+- `ImportError` / native load issues: rebuild and ensure the native library is discoverable.
+- Empty indicator values: verify you have enough columns for the configured lookback periods.
+- Unexpected chart shape: ensure `HighLow` mode receives real high/low values, not close-only values.
+
+## Documentation and Links
+
+- Python API reference: `docs/bindings/python.md`
+- Cross-language API index: `docs/reference/api-symbol-index.md`
+- Source: https://github.com/gregorian-09/pnf-chart-system
+- Issues: https://github.com/gregorian-09/pnf-chart-system/issues
+- Changelog: https://github.com/gregorian-09/pnf-chart-system/blob/master/CHANGELOG.md

pnf_chart_system-0.1.1/VERSION

@@ -0,0 +1 @@
+0.1.1

pnf_chart_system-0.1.1/pnf_chart_system.egg-info/PKG-INFO

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: pnf-chart-system
+Version: 0.1.1
+Summary: Point and Figure Chart Library - Python bindings
+Home-page: https://github.com/gregorian-09/pnf-chart-system
+Author: Gregorian Rayne
+Author-email: gregorianrayne09@gmail.com
+Project-URL: Documentation, https://github.com/gregorian-09/pnf-chart-system/tree/master/docs
+Project-URL: API Reference, https://github.com/gregorian-09/pnf-chart-system/blob/master/docs/bindings/python.md
+Project-URL: Changelog, https://github.com/gregorian-09/pnf-chart-system/blob/master/CHANGELOG.md
+Project-URL: Issues, https://github.com/gregorian-09/pnf-chart-system/issues
+Project-URL: Source, https://github.com/gregorian-09/pnf-chart-system
+Keywords: point-and-figure,charting,technical-analysis,trading,indicators
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+# pnf-chart-system
+
+[![PyPI version](https://img.shields.io/pypi/v/pnf-chart-system.svg)](https://pypi.org/project/pnf-chart-system/)
+[![Python versions](https://img.shields.io/pypi/pyversions/pnf-chart-system.svg)](https://pypi.org/project/pnf-chart-system/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/gregorian-09/pnf-chart-system/blob/master/LICENSE)
+
+Production-ready Python bindings for the PnF (Point and Figure) engine.
+
+Package name is `pnf-chart-system`; import name is `pypnf`.
+
+## Why This Package
+
+`pypnf` is built for real analysis workflows, not only chart construction:
+
+| Area | What you get |
+| --- | --- |
+| Chart Engine | Point-and-Figure charting with `Close` and `HighLow` construction |
+| Trend Context | Bullish support / bearish resistance context checks |
+| Indicators | SMA, Bollinger Bands, RSI, OBV, Bullish Percent |
+| Structural Signals | Buy/sell signals and full PnF pattern detection |
+| Market Structure | Support/resistance levels, price objectives, congestion zones |
+| Visualization | Localhost real-time dashboard streaming |
+
+## Installation
+
+```bash
+pip install pnf-chart-system
+```
+
+## Quick Start
+
+```python
+import pypnf
+
+cfg = pypnf.ChartConfig()
+cfg.method = pypnf.ConstructionMethod.HighLow
+cfg.box_size_method = pypnf.BoxSizeMethod.Traditional
+cfg.box_size = 0.0
+cfg.reversal = 3
+
+chart = pypnf.Chart(cfg)
+
+# high, low, close, timestamp
+chart.add_data(5000.0, 4950.0, 4985.0, 1700000000)
+chart.add_data(5040.0, 4980.0, 5030.0, 1700003600)
+chart.add_data(5065.0, 5010.0, 5055.0, 1700007200)
+
+indicators = pypnf.Indicators(pypnf.IndicatorConfig())
+indicators.calculate(chart)
+
+print(chart.to_ascii())
+print(indicators.summary())
+```
+
+## Trendline and Bias Workflow
+
+```python
+last_price = 5055.0
+
+print("Bullish bias:", chart.has_bullish_bias())
+print("Bearish bias:", chart.has_bearish_bias())
+print("Above bullish support:", chart.is_above_bullish_support(last_price))
+print("Below bearish resistance:", chart.is_below_bearish_resistance(last_price))
+```
+
+These checks are the normal first gate before acting on breakout or breakdown patterns.
+
+## Indicators and Momentum
+
+```python
+indicators.calculate(chart)
+
+sma_short = indicators.sma_short()
+bands = indicators.bollinger()
+rsi = indicators.rsi()
+obv = indicators.obv()
+
+col = chart.column_count() - 1
+if col >= 0:
+    print("SMA short:", sma_short.value(col))
+    print("Bollinger upper:", bands.upper(col))
+    print("RSI:", rsi.value(col))
+    print("OBV:", obv.value(col))
+```
+
+## Signals and Pattern Detection
+
+```python
+signals = indicators.signals()
+patterns = indicators.patterns()
+
+print("Current signal:", signals.current_signal())
+print("Buy count:", signals.buy_count())
+print("Sell count:", signals.sell_count())
+
+print("Pattern count:", patterns.pattern_count())
+print("Bullish patterns:", len(patterns.bullish_patterns()))
+print("Bearish patterns:", len(patterns.bearish_patterns()))
+```
+
+## Support, Resistance, Objectives, Congestion
+
+```python
+sr = indicators.support_resistance()
+obj = indicators.objectives()
+cong = indicators.congestion()
+
+print("Support levels:", sr.support_levels())
+print("Resistance levels:", sr.resistance_levels())
+print("Significant levels (>=3 touches):", sr.significant_levels(3))
+
+print("Bullish targets:", obj.bullish_targets())
+print("Bearish targets:", obj.bearish_targets())
+
+print("Congestion zones:", cong.zones())
+```
+
+## Real-Time Dashboard
+
+```python
+from pypnf_dashboard import DashboardServer
+
+server = DashboardServer(chart, indicators)
+server.start("127.0.0.1", 8761)
+server.publish()
+print(server.url())
+```
+
+You can call `server.publish()` after each new bar/tick batch to keep the browser in sync.
+
+## API Map
+
+Core:
+- `Chart`, `ChartConfig`, `Box`, `Column`
+
+Indicators:
+- `Indicators`, `IndicatorConfig`
+- `MovingAverage`, `BollingerBands`, `RSI`, `OnBalanceVolume`, `BullishPercent`
+- `SignalDetector`, `PatternRecognizer`, `SupportResistance`, `PriceObjectiveCalculator`, `CongestionDetector`
+
+Data:
+- `OHLC`, `Signal`, `Pattern`, `SupportResistanceLevel`, `PriceObjective`, `CongestionZone`
+
+Enums:
+- `BoxType`, `ColumnType`, `ConstructionMethod`, `BoxSizeMethod`, `SignalType`, `PatternType`
+
+## Versioning and Compatibility
+
+- Python package version tracks the same release as the core engine.
+- Keep all bindings on the same version when mixing languages in one system.
+- See `CHANGELOG.md` for version-by-version behavior changes.
+
+## Troubleshooting
+
+- `ImportError` / native load issues: rebuild and ensure the native library is discoverable.
+- Empty indicator values: verify you have enough columns for the configured lookback periods.
+- Unexpected chart shape: ensure `HighLow` mode receives real high/low values, not close-only values.
+
+## Documentation and Links
+
+- Python API reference: `docs/bindings/python.md`
+- Cross-language API index: `docs/reference/api-symbol-index.md`
+- Source: https://github.com/gregorian-09/pnf-chart-system
+- Issues: https://github.com/gregorian-09/pnf-chart-system/issues
+- Changelog: https://github.com/gregorian-09/pnf-chart-system/blob/master/CHANGELOG.md

pnf_chart_system-0.1.1/pnf_chart_system.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+MANIFEST.in
+README.md
+VERSION
+pypnf_dashboard.py
+setup.py
+pnf_chart_system.egg-info/PKG-INFO
+pnf_chart_system.egg-info/SOURCES.txt
+pnf_chart_system.egg-info/dependency_links.txt
+pnf_chart_system.egg-info/top_level.txt

pnf_chart_system-0.1.1/pnf_chart_system.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pnf_chart_system-0.1.1/pnf_chart_system.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+pypnf
+pypnf_dashboard

pnf_chart_system-0.1.1/pypnf_dashboard.py

@@ -0,0 +1,424 @@
+"""Localhost real-time dashboard for pypnf."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import os
+import socket
+import threading
+import time
+from dataclasses import dataclass
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from typing import Any
+
+import pypnf
+
+_WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
+
+def _repo_root() -> Path:
+    return Path(__file__).resolve().parents[2]
+
+
+def _asset_path(name: str) -> Path:
+    return _repo_root() / "dashboard" / "web" / name
+
+
+def _enum_name(value: Any) -> str:
+    if hasattr(value, "name"):
+        return str(value.name)
+    return str(value)
+
+
+def build_snapshot(chart: Any, indicators: Any | None = None, sequence: int = 1) -> dict[str, Any]:
+    column_count = int(chart.column_count())
+    columns = []
+    for idx in range(column_count):
+        box_count = int(chart.column_box_count(idx))
+        boxes = []
+        for box_idx in range(box_count):
+            boxes.append(
+                {
+                    "index": box_idx,
+                    "price": float(chart.box_price(idx, box_idx)),
+                    "type": _enum_name(chart.box_type(idx, box_idx)),
+                    "marker": str(chart.box_marker(idx, box_idx) or ""),
+                }
+            )
+        columns.append(
+            {
+                "index": idx,
+                "type": _enum_name(chart.column_type(idx)),
+                "box_count": box_count,
+                "highest": float(chart.column_high(idx)),
+                "lowest": float(chart.column_low(idx)),
+                "boxes": boxes,
+            }
+        )
+
+    indicator_payload = {
+        "summary": "",
+        "detailed_summary": "",
+        "bullish_percent": 0.0,
+        "signal_count": 0,
+        "buy_signal_count": 0,
+        "sell_signal_count": 0,
+        "pattern_count": 0,
+        "support_level_count": 0,
+        "resistance_level_count": 0,
+        "congestion_zone_count": 0,
+        "signals": [],
+        "patterns": [],
+        "support_levels": [],
+        "resistance_levels": [],
+        "price_objectives": [],
+        "congestion_zones": [],
+        "series": {
+            "sma_short": [],
+            "sma_medium": [],
+            "sma_long": [],
+            "bollinger_middle": [],
+            "bollinger_upper": [],
+            "bollinger_lower": [],
+            "rsi": [],
+        },
+    }
+    if indicators is not None:
+        try:
+            signal_detector = indicators.signals()
+            pattern_recognizer = indicators.patterns()
+            support_resistance = indicators.support_resistance()
+            objectives = indicators.objectives()
+            congestion = indicators.congestion()
+            sma_short = [float(v) for v in indicators.sma_short().values_copy()]
+            sma_medium = [float(v) for v in indicators.sma_medium().values_copy()]
+            sma_long = [float(v) for v in indicators.sma_long().values_copy()]
+            bollinger = indicators.bollinger()
+            rsi = indicators.rsi()
+            signals = [
+                {
+                    "type": _enum_name(signal.type),
+                    "column_index": int(signal.column_index),
+                    "price": float(signal.price),
+                }
+                for signal in signal_detector.signals()
+            ]
+            patterns = [
+                {
+                    "type": _enum_name(pattern.type),
+                    "start_column": int(pattern.start_column),
+                    "end_column": int(pattern.end_column),
+                    "price": float(pattern.price),
+                    "is_bullish": bool(pattern.is_bullish()),
+                }
+                for pattern in pattern_recognizer.patterns()
+            ]
+            support_levels = [
+                {
+                    "type": "Support",
+                    "price": float(level.price),
+                    "touches": int(level.touch_count),
+                }
+                for level in support_resistance.support_levels()
+            ]
+            resistance_levels = [
+                {
+                    "type": "Resistance",
+                    "price": float(level.price),
+                    "touches": int(level.touch_count),
+                }
+                for level in support_resistance.resistance_levels()
+            ]
+            price_objectives = [
+                {
+                    "target": float(objective.target_price),
+                    "column_index": int(objective.base_column),
+                    "box_count": int(objective.box_count),
+                    "is_bullish": bool(objective.is_bullish),
+                }
+                for objective in objectives.objectives()
+            ]
+            congestion_zones = [
+                {
+                    "start_column": int(zone.start_column),
+                    "end_column": int(zone.end_column),
+                    "high_price": float(zone.high_price),
+                    "low_price": float(zone.low_price),
+                    "column_count": int(zone.column_count),
+                }
+                for zone in congestion.zones()
+            ]
+            indicator_payload.update(
+                {
+                    "summary": str(indicators.summary()),
+                    "detailed_summary": str(indicators),
+                    "bullish_percent": float(indicators.bullish_percent().value()),
+                    "signal_count": int(signal_detector.buy_count() + signal_detector.sell_count()),
+                    "buy_signal_count": int(signal_detector.buy_count()),
+                    "sell_signal_count": int(signal_detector.sell_count()),
+                    "pattern_count": int(pattern_recognizer.pattern_count()),
+                    "support_level_count": len(support_levels),
+                    "resistance_level_count": len(resistance_levels),
+                    "congestion_zone_count": len(congestion_zones),
+                    "signals": signals,
+                    "patterns": patterns,
+                    "support_levels": support_levels,
+                    "resistance_levels": resistance_levels,
+                    "price_objectives": price_objectives,
+                    "congestion_zones": congestion_zones,
+                    "series": {
+                        "sma_short": sma_short,
+                        "sma_medium": sma_medium,
+                        "sma_long": sma_long,
+                        "bollinger_middle": [float(v) for v in bollinger.middle_copy()],
+                        "bollinger_upper": [float(v) for v in bollinger.upper_copy()],
+                        "bollinger_lower": [float(v) for v in bollinger.lower_copy()],
+                        "rsi": [float(v) for v in rsi.values_copy()],
+                    },
+                }
+            )
+        except Exception:
+            indicator_payload["summary"] = "Indicator snapshot unavailable"
+            indicator_payload["detailed_summary"] = "Detailed indicator snapshot unavailable"
+
+    return {
+        "type": "dashboard.snapshot",
+        "version": 1,
+        "timestamp": int(time.time() * 1000),
+        "sequence": sequence,
+        "payload": {
+            "meta": {
+                "binding": "python",
+                "library_version": pypnf.version(),
+                "server_version": "1",
+                "stream_state": "running",
+            },
+            "chart": {
+                "box_size": float(chart.current_box_size()),
+                "column_count": column_count,
+                "x_column_count": int(chart.x_column_count()),
+                "o_column_count": int(chart.o_column_count()),
+                "has_bullish_bias": bool(chart.has_bullish_bias()),
+                "has_bearish_bias": bool(chart.has_bearish_bias()),
+                "columns": columns,
+            },
+            "indicators": indicator_payload,
+        },
+    }
+
+
+class _DashboardHandler(BaseHTTPRequestHandler):
+    server_version = "PnFPythonDashboard/1.0"
+
+    def do_GET(self) -> None:
+        dashboard = self.server.dashboard_server  # type: ignore[attr-defined]
+        if self.headers.get("Upgrade", "").lower() == "websocket" and self.path == "/ws":
+            self._handle_ws(dashboard)
+            return
+        if self.path == "/healthz":
+            self._send_bytes(200, b"ok", "text/plain; charset=utf-8")
+            return
+        if self.path == "/snapshot":
+            self._send_bytes(200, dashboard.snapshot_json().encode("utf-8"), "application/json; charset=utf-8")
+            return
+        if self.path == "/app.js":
+            self._send_file(_asset_path("app.js"), "application/javascript; charset=utf-8")
+            return
+        if self.path == "/styles.css":
+            self._send_file(_asset_path("styles.css"), "text/css; charset=utf-8")
+            return
+        if self.path == "/" or self.path == "/index.html":
+            html = _asset_path("index.html").read_text(encoding="utf-8")
+            ws_url = f"ws://{dashboard.host}:{dashboard.port}/ws"
+            html = html.replace(
+                "window.PNF_DASHBOARD_CONFIG = window.PNF_DASHBOARD_CONFIG || {};",
+                f"window.PNF_DASHBOARD_CONFIG = {{ wsUrl: {json.dumps(ws_url)} }};",
+            )
+            self._send_bytes(200, html.encode("utf-8"), "text/html; charset=utf-8")
+            return
+        self._send_bytes(404, b"not found", "text/plain; charset=utf-8")
+
+    def log_message(self, format: str, *args: Any) -> None:  # noqa: A003
+        return
+
+    def _send_file(self, path: Path, content_type: str) -> None:
+        self._send_bytes(200, path.read_bytes(), content_type)
+
+    def _send_bytes(self, status: int, payload: bytes, content_type: str) -> None:
+        self.send_response(status)
+        self.send_header("Content-Type", content_type)
+        self.send_header("Content-Length", str(len(payload)))
+        self.send_header("Cache-Control", "no-store")
+        self.end_headers()
+        self.wfile.write(payload)
+
+    def _handle_ws(self, dashboard: "DashboardServer") -> None:
+        key = self.headers.get("Sec-WebSocket-Key")
+        if not key:
+            self.send_error(400, "Missing Sec-WebSocket-Key")
+            return
+        accept = base64.b64encode(hashlib.sha1((key + _WS_GUID).encode("utf-8")).digest()).decode("ascii")
+        self.connection.sendall(
+            (
+                "HTTP/1.1 101 Switching Protocols\r\n"
+                "Upgrade: websocket\r\n"
+                "Connection: Upgrade\r\n"
+                f"Sec-WebSocket-Accept: {accept}\r\n\r\n"
+            ).encode("utf-8")
+        )
+        self.connection.setblocking(True)
+        dashboard._register_client(self.connection)
+        try:
+            while dashboard.is_running:
+                time.sleep(1.0)
+        finally:
+            dashboard._unregister_client(self.connection)
+            try:
+                self.connection.close()
+            except OSError:
+                pass
+
+
+@dataclass
+class DashboardServer:
+    chart: Any | None = None
+    indicators: Any | None = None
+
+    def __post_init__(self) -> None:
+        self.host = "127.0.0.1"
+        self.port = 0
+        self._server: ThreadingHTTPServer | None = None
+        self._thread: threading.Thread | None = None
+        self._clients: list[socket.socket] = []
+        self._clients_lock = threading.Lock()
+        self._sequence = 0
+        self._latest = json.dumps({
+            "type": "dashboard.snapshot",
+            "version": 1,
+            "timestamp": int(time.time() * 1000),
+            "sequence": 0,
+            "payload": {
+                "meta": {"binding": "python", "library_version": pypnf.version(), "server_version": "1", "stream_state": "idle"},
+                "chart": {"box_size": 0, "column_count": 0, "x_column_count": 0, "o_column_count": 0, "has_bullish_bias": False, "has_bearish_bias": False, "columns": []},
+                "indicators": {"summary": "", "detailed_summary": "", "bullish_percent": 0, "signal_count": 0, "buy_signal_count": 0, "sell_signal_count": 0, "pattern_count": 0, "support_level_count": 0, "resistance_level_count": 0, "congestion_zone_count": 0, "signals": [], "patterns": [], "support_levels": [], "resistance_levels": [], "price_objectives": [], "congestion_zones": [], "series": {"sma_short": [], "sma_medium": [], "sma_long": [], "bollinger_middle": [], "bollinger_upper": [], "bollinger_lower": [], "rsi": []}},
+            },
+        })
+        self._running = threading.Event()
+        self._publisher_stop = threading.Event()
+        self._publisher_thread: threading.Thread | None = None
+
+    @property
+    def is_running(self) -> bool:
+        return self._running.is_set()
+
+    def set_chart(self, chart: Any) -> None:
+        self.chart = chart
+
+    def set_indicators(self, indicators: Any) -> None:
+        self.indicators = indicators
+
+    def start(self, host: str = "127.0.0.1", port: int = 0) -> str:
+        if self._server is not None:
+            return self.url()
+        self.host = host
+        self._server = ThreadingHTTPServer((host, port), _DashboardHandler)
+        self._server.dashboard_server = self  # type: ignore[attr-defined]
+        self.port = int(self._server.server_address[1])
+        self._running.set()
+        self._thread = threading.Thread(target=self._server.serve_forever, name="pypnf-dashboard", daemon=True)
+        self._thread.start()
+        return self.url()
+
+    def url(self) -> str:
+        return f"http://{self.host}:{self.port}/"
+
+    def snapshot(self) -> dict[str, Any]:
+        if self.chart is None:
+            return json.loads(self._latest)
+        self._sequence += 1
+        return build_snapshot(self.chart, self.indicators, self._sequence)
+
+    def snapshot_json(self) -> str:
+        return self._latest
+
+    def publish(self) -> str:
+        snap = self.snapshot()
+        self._latest = json.dumps(snap)
+        self._broadcast(self._latest)
+        return self._latest
+
+    def start_auto_publish(self, interval_ms: int = 250) -> None:
+        self.stop_auto_publish()
+        self._publisher_stop.clear()
+
+        def _loop() -> None:
+            while not self._publisher_stop.wait(interval_ms / 1000.0):
+                if self.is_running and self.chart is not None:
+                    self.publish()
+
+        self._publisher_thread = threading.Thread(target=_loop, name="pypnf-dashboard-publisher", daemon=True)
+        self._publisher_thread.start()
+
+    def stop_auto_publish(self) -> None:
+        self._publisher_stop.set()
+        self._publisher_thread = None
+
+    def stop(self) -> None:
+        self.stop_auto_publish()
+        self._running.clear()
+        if self._server is not None:
+            self._server.shutdown()
+            self._server.server_close()
+            self._server = None
+        with self._clients_lock:
+            clients = list(self._clients)
+            self._clients.clear()
+        for sock in clients:
+            try:
+                sock.close()
+            except OSError:
+                pass
+
+    def _register_client(self, sock: socket.socket) -> None:
+        with self._clients_lock:
+            self._clients.append(sock)
+        if self._latest:
+            self._send_ws_text(sock, self._latest)
+
+    def _unregister_client(self, sock: socket.socket) -> None:
+        with self._clients_lock:
+            self._clients = [client for client in self._clients if client is not sock]
+
+    def _broadcast(self, message: str) -> None:
+        with self._clients_lock:
+            clients = list(self._clients)
+        stale = []
+        for sock in clients:
+            try:
+                self._send_ws_text(sock, message)
+            except OSError:
+                stale.append(sock)
+        for sock in stale:
+            self._unregister_client(sock)
+            try:
+                sock.close()
+            except OSError:
+                pass
+
+    @staticmethod
+    def _send_ws_text(sock: socket.socket, message: str) -> None:
+        payload = message.encode("utf-8")
+        length = len(payload)
+        if length < 126:
+            header = bytes([0x81, length])
+        elif length < 65536:
+            header = bytes([0x81, 126]) + length.to_bytes(2, "big")
+        else:
+            header = bytes([0x81, 127]) + length.to_bytes(8, "big")
+        sock.sendall(header + payload)
+
+
+__all__ = ["DashboardServer", "build_snapshot"]

pnf_chart_system-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pnf_chart_system-0.1.1/setup.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""
+Setup script for pypnf - Point and Figure Chart Library Python bindings.
+
+Build modes:
+  1. Standalone (bundles C++ sources): pip install .
+  2. System library (links to installed libpnf): pip install . --config-settings=--build-option=--use-system-lib
+"""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from setuptools import setup, Extension
+from setuptools.command.build_ext import build_ext
+
+
+def read_project_version() -> str:
+    """Read the canonical project version from the repo root VERSION file."""
+    env_version = os.environ.get("PNF_VERSION", "").strip()
+    if env_version:
+        return env_version
+
+    candidates = [
+        Path(__file__).resolve().parent / "VERSION",
+        Path(__file__).resolve().parents[2] / "VERSION",
+    ]
+    for version_file in candidates:
+        if version_file.exists():
+            return version_file.read_text(encoding="utf-8").strip()
+
+    raise FileNotFoundError(
+        "Could not locate VERSION file. Set PNF_VERSION or provide bindings/python/VERSION."
+    )
+
+
+def read_readme() -> str:
+    """Read the package README shown on PyPI."""
+    return (Path(__file__).resolve().parent / "README.md").read_text(encoding="utf-8")
+
+
+class CMakeExtension(Extension):
+    """Extension that uses CMake for building."""
+    def __init__(self, name, sourcedir=""):
+        super().__init__(name, sources=[])
+        self.sourcedir = os.path.abspath(sourcedir)
+
+
+class CMakeBuild(build_ext):
+    """Build extension using CMake."""
+
+    def build_extension(self, ext):
+        if not isinstance(ext, CMakeExtension):
+            super().build_extension(ext)
+            return
+
+        extdir = os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name)))
+
+        # Ensure output directory exists
+        if not os.path.exists(extdir):
+            os.makedirs(extdir)
+
+        # CMake configuration
+        cmake_args = [
+            f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={extdir}",
+            f"-DPYTHON_EXECUTABLE={sys.executable}",
+            "-DPNF_BUILD_PYTHON=ON",
+            "-DPNF_BUILD_TESTS=OFF",
+            "-DPNF_BUILD_EXAMPLES=OFF",
+            "-DPNF_BUILD_VIEWER=OFF",
+        ]
+
+        # Build type
+        cfg = "Debug" if self.debug else "Release"
+        cmake_args.append(f"-DCMAKE_BUILD_TYPE={cfg}")
+
+        build_args = ["--config", cfg]
+
+        # Parallel build
+        if "CMAKE_BUILD_PARALLEL_LEVEL" not in os.environ:
+            build_args += ["--", "-j4"]
+
+        # Build directory
+        build_temp = os.path.join(self.build_temp, ext.name)
+        if not os.path.exists(build_temp):
+            os.makedirs(build_temp)
+
+        # Run CMake
+        subprocess.check_call(["cmake", ext.sourcedir] + cmake_args, cwd=build_temp)
+        subprocess.check_call(["cmake", "--build", ".", "--target", "pypnf"] + build_args, cwd=build_temp)
+
+
+# Alternative: pybind11 direct build (simpler but requires pre-built libpnf)
+def get_pybind11_extension():
+    """Create extension using pybind11 directly (requires system libpnf)."""
+    try:
+        import pybind11
+        pybind11_include = pybind11.get_include()
+    except ImportError:
+        pybind11_include = ""
+
+    # Find library paths
+    root_directory = Path(__file__).parent.parent.parent
+    include_dir = root_directory / "include"
+
+    return Extension(
+        "pypnf",
+        sources=["pnf_python.cpp"],
+        include_dirs=[
+            str(include_dir),
+            pybind11_include,
+        ],
+        libraries=["pnf"],
+        language="c++",
+        extra_compile_args=["-std=c++20", "-O3", "-Wall"],
+    )
+
+
+# Determine build mode
+USE_CMAKE = True  # Set to False if you want direct pybind11 build with system library
+
+if USE_CMAKE:
+    # CMake build bundles everything
+    root_dir = str(Path(__file__).parent.parent.parent)
+    ext_modules = [CMakeExtension("pypnf", sourcedir=root_dir)]
+    cmdclass = {"build_ext": CMakeBuild}
+else:
+    # Direct pybind11 build requires pre-installed libpnf
+    ext_modules = [get_pybind11_extension()]
+    cmdclass = {}
+
+
+setup(
+    name="pnf-chart-system",
+    version=read_project_version(),
+    author="Gregorian Rayne",
+    author_email="gregorianrayne09@gmail.com",
+    description="Point and Figure Chart Library - Python bindings",
+    long_description=read_readme(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/gregorian-09/pnf-chart-system",
+    project_urls={
+        "Documentation": "https://github.com/gregorian-09/pnf-chart-system/tree/master/docs",
+        "API Reference": "https://github.com/gregorian-09/pnf-chart-system/blob/master/docs/bindings/python.md",
+        "Changelog": "https://github.com/gregorian-09/pnf-chart-system/blob/master/CHANGELOG.md",
+        "Issues": "https://github.com/gregorian-09/pnf-chart-system/issues",
+        "Source": "https://github.com/gregorian-09/pnf-chart-system",
+    },
+    ext_modules=ext_modules,
+    py_modules=["pypnf_dashboard"],
+    cmdclass=cmdclass,
+    python_requires=">=3.8",
+    keywords="point-and-figure, charting, technical-analysis, trading, indicators",
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Financial and Insurance Industry",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+    ],
+)