haystack-py 0.1.3__py3-none-any.whl

haystack_py-0.1.3.dist-info/METADATA

@@ -0,0 +1,446 @@
+Metadata-Version: 2.4
+Name: haystack-py
+Version: 0.1.3
+Summary: Async Project Haystack client and ontology library for Python
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: aiohttp>=3.10
+Requires-Dist: cryptography>=42.0
+Requires-Dist: orjson>=3.10
+Requires-Dist: rdflib>=7.0
+Requires-Dist: websockets>=14.0
+Provides-Extra: all
+Requires-Dist: asyncpg>=0.30; extra == 'all'
+Requires-Dist: fastapi>=0.115; extra == 'all'
+Requires-Dist: redis[hiredis]>=5.2; extra == 'all'
+Requires-Dist: uvicorn[standard]>=0.32; extra == 'all'
+Provides-Extra: server
+Requires-Dist: fastapi>=0.115; extra == 'server'
+Requires-Dist: redis[hiredis]>=5.2; extra == 'server'
+Requires-Dist: uvicorn[standard]>=0.32; extra == 'server'
+Provides-Extra: timescale
+Requires-Dist: asyncpg>=0.30; extra == 'timescale'
+Description-Content-Type: text/markdown
+
+# haystack-py
+
+[![PyPI](https://img.shields.io/pypi/v/haystack-py)](https://pypi.org/project/haystack-py/)
+[![Python](https://img.shields.io/pypi/pyversions/haystack-py)](https://pypi.org/project/haystack-py/)
+[![License](https://img.shields.io/github/license/jscott3201/hs-py)](LICENSE)
+[![CI](https://github.com/jscott3201/hs-py/actions/workflows/ci.yml/badge.svg)](https://github.com/jscott3201/hs-py/actions/workflows/ci.yml)
+
+Asynchronous [Project Haystack](https://project-haystack.org/) client and server library for Python 3.13+. HTTP and WebSocket transports, four wire formats, SCRAM-SHA-256 and mTLS authentication, pluggable storage backends (Redis, TimescaleDB), and full ontology support. Built on native `asyncio`.
+
+[Documentation](https://jscott3201.github.io/hs-py/) | [Getting Started](https://jscott3201.github.io/hs-py/getting-started.html) | [API Reference](https://jscott3201.github.io/hs-py/api/index.html) | [Changelog](CHANGELOG.md)
+
+```python
+from hs_py import Client
+
+async with Client("http://server/api", "admin", "secret") as c:
+    about = await c.about()
+    points = await c.read("point and temp and sensor")
+```
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Storage Backends](#storage-backends)
+- [Architecture](#architecture)
+- [Configuration](#configuration)
+- [Testing](#testing)
+- [Requirements](#requirements)
+- [License](#license)
+
+## Features
+
+| Category | Highlights |
+|----------|-----------|
+| **Transports** | HTTP with aiohttp, WebSocket with `websockets` sans-I/O, persistent connections, per-message deflate compression |
+| **Client** | `Client` (HTTP) and `WebSocketClient` with all 13 standard ops, batch requests, watch subscriptions, auto-auth |
+| **Server** | FastAPI application factory, SCRAM-SHA-256 middleware, content negotiation (JSON/Zinc/Trio/CSV), standalone `WebSocketServer` |
+| **Wire Formats** | JSON v3/v4 (`orjson`), Zinc (text), Trio (tagged records), CSV (export-only) |
+| **Authentication** | SCRAM-SHA-256 over HTTP and WebSocket, PLAINTEXT fallback, token-based WebSocket auth, mTLS with `CertAuthenticator` |
+| **TLS** | TLS 1.3 enforced, mutual authentication, test certificate generation (EC P-256), `TLSConfig` dataclass |
+| **Storage** | Pluggable `StorageAdapter` protocol with Redis (RediSearch + RedisTimeSeries), TimescaleDB (asyncpg + JSONB), and in-memory backends |
+| **Data Model** | All Haystack value types as frozen dataclasses, `Grid` / `GridBuilder` as universal message format |
+| **Filters** | Recursive descent parser, AST representation, evaluation against dicts and grids, SQL pushdown for JSONB/RediSearch |
+| **Ontology** | Def/Lib/Namespace model, taxonomy queries, tag normalization, dict-to-def reflection |
+| **WebSocket Extras** | `ReconnectingWebSocketClient` with backoff, `WebSocketPool` / `ChannelClient` multiplexing, binary frame codec |
+| **Observability** | `MetricsHooks` for connection, message, request, and error callbacks |
+| **Watch** | Server-side `WatchState` delta encoding, client-side `WatchAccumulator` delta merging |
+| **Quality** | 1,200+ tests, 69 end-to-end integration tests, 122 TimescaleDB tests, mypy strict, ruff linting, frozen dataclasses throughout |
+
+## Installation
+
+```bash
+pip install haystack-py
+```
+
+Optional extras:
+
+```bash
+pip install haystack-py[server]       # FastAPI + Redis backend (server-side)
+pip install haystack-py[timescale]    # TimescaleDB/PostgreSQL backend
+pip install haystack-py[rdf]          # RDF ontology import (rdflib)
+pip install haystack-py[all]          # All optional dependencies
+```
+
+### Development
+
+```bash
+git clone https://github.com/jscott3201/hs-py.git
+cd hs-py
+uv sync --group dev
+```
+
+## Quick Start
+
+### HTTP Client
+
+```python
+import asyncio
+from hs_py import Client, Ref
+
+
+async def main():
+    async with Client("http://server/api", "admin", "secret") as c:
+        # Server info
+        about = await c.about()
+        print(about[0]["serverName"])
+
+        # Filter-based read
+        sites = await c.read("site")
+        for row in sites:
+            print(row.get("dis"), row.get("id"))
+
+        # ID-based read
+        entities = await c.read_by_ids([Ref("site-1"), Ref("equip-2")])
+
+        # Navigation
+        nav = await c.nav()  # root sites
+        children = await c.nav(Ref("site-1"))  # site's equips
+
+        # History
+        history = await c.his_read(Ref("point-1"), "yesterday")
+        for row in history:
+            print(row["ts"], row["val"])
+
+        # Write a point value
+        await c.point_write(Ref("point-1"), level=8, val=72.5)
+
+
+asyncio.run(main())
+```
+
+### WebSocket Client
+
+```python
+import asyncio
+from hs_py import WebSocketClient, Grid, Ref
+
+
+async def main():
+    async with WebSocketClient("ws://server/api/ws", auth_token="token") as ws:
+        about = await ws.about()
+
+        # Batch: multiple ops in one round-trip
+        results = await ws.batch(
+            ("about", Grid.make_empty()),
+            ("read", Grid.make_rows([{"filter": "site"}])),
+            ("read", Grid.make_rows([{"filter": "point and temp"}])),
+        )
+
+        # Watch: subscribe to entity changes
+        watch = await ws.watch_sub([Ref("p-1"), Ref("p-2")], "my-watch")
+        watch_id = watch.meta["watchId"]
+        poll = await ws.watch_poll(watch_id)
+        await ws.watch_close(watch_id)
+
+
+asyncio.run(main())
+```
+
+### Server
+
+```python
+import asyncio
+from hs_py.ops import HaystackOps
+from hs_py.storage.memory import MemoryAdapter
+from hs_py.auth_types import SimpleAuthenticator
+from hs_py.fastapi_server import create_app
+import uvicorn
+
+
+async def main():
+    storage = MemoryAdapter()
+    await storage.start()
+    await storage.load_entities([
+        {"id": Ref("s1"), "site": MARKER, "dis": "My Building"},
+    ])
+
+    ops = HaystackOps(storage=storage)
+    auth = SimpleAuthenticator({"admin": "secret"})
+    app = create_app(ops, authenticator=auth)
+    config = uvicorn.Config(app, host="0.0.0.0", port=8080)
+    server = uvicorn.Server(config)
+    await server.serve()
+
+
+asyncio.run(main())
+```
+
+### Wire Formats
+
+```python
+from hs_py.encoding import json, zinc, trio, csv
+from hs_py.encoding.json import JsonVersion
+
+# JSON v4
+grid = json.decode_grid(data, version=JsonVersion.V4)
+json_bytes = json.encode_grid(grid, version=JsonVersion.V4)
+
+# Zinc
+zinc_text = zinc.encode_grid(grid)
+grid = zinc.decode_grid(zinc_text)
+
+# Trio records
+records = trio.parse_trio(trio_text)
+trio_text = trio.encode_trio(records)
+
+# CSV (encode-only)
+csv_text = csv.encode_grid(grid)
+```
+
+### Filters
+
+```python
+from hs_py import MARKER, parse, evaluate, evaluate_grid
+
+# Parse filter to AST
+ast = parse("point and temp and sensor")
+
+# Evaluate against a dict
+entity = {"point": MARKER, "temp": MARKER, "sensor": MARKER}
+assert evaluate(ast, entity) is True
+
+# Filter a grid
+matching = evaluate_grid(ast, grid)
+```
+
+### Ontology
+
+```python
+from hs_py.ontology.namespace import Namespace, load_lib_from_trio
+from hs_py.ontology.reflect import reflect
+
+lib = load_lib_from_trio(trio_text)
+ns = Namespace([lib])
+
+# Taxonomy queries
+assert ns.is_subtype("ahu", "equip")
+subtypes = ns.subtypes("equip")  # [ahu, vav, ...]
+
+# Reflect entities against definitions
+defs = reflect(ns, entity_dict)
+```
+
+## Storage Backends
+
+haystack-py defines a `StorageAdapter` protocol that decouples server operations from data storage. Three implementations are provided:
+
+| Backend | Module | Best For |
+|---------|--------|----------|
+| **Memory** | `storage.memory` | Testing, prototyping, small datasets |
+| **Redis** | `storage.redis` | Production with RediSearch full-text and RedisTimeSeries |
+| **TimescaleDB** | `storage.timescale` | Production with PostgreSQL JSONB and time-series hypertables |
+
+### Redis
+
+```python
+from hs_py.storage.redis import RedisAdapter, create_redis_client
+
+r = await create_redis_client("redis://localhost:6379")
+adapter = RedisAdapter(r)
+await adapter.start()
+```
+
+Features: RediSearch indexes for filter queries, RedisTimeSeries for history, pub/sub for watch notifications.
+
+### TimescaleDB
+
+```python
+from hs_py.storage.timescale import TimescaleAdapter, create_timescale_pool
+
+pool = await create_timescale_pool("postgresql://localhost/haystack")
+adapter = TimescaleAdapter(pool)
+await adapter.start()  # Creates schema + hypertable
+```
+
+Features: JSONB entity storage with GIN indexes, filter AST → SQL pushdown, hypertable time-series, COPY-based bulk loading.
+
+## Architecture
+
+```
+src/hs_py/
+  kinds.py            Haystack value types (Marker, Number, Ref, Coord, etc.)
+  grid.py             Grid, Col, GridBuilder -- universal message format
+  errors.py           Exception hierarchy (HaystackError, CallError, AuthError)
+  auth.py             SCRAM-SHA-256 / PLAINTEXT client auth handshake
+  auth_types.py       Authenticator protocol, SimpleAuthenticator, CertAuthenticator
+  client.py           Async HTTP client with all standard ops
+  ops.py              HaystackOps base class with storage-backed op dispatch
+  fastapi_server.py   FastAPI application factory, SCRAM middleware, WebSocket endpoint
+  metrics.py          MetricsHooks for transport-level observability
+  tls.py              TLSConfig, SSL context builders, certificate generation
+  security.py         Security hardening utilities
+  watch.py            WatchState (server delta), WatchAccumulator (client merge)
+  ws.py               Sans-I/O WebSocket wrapper (websockets library)
+  ws_client.py        WebSocketClient, ReconnectingWebSocketClient, WebSocketPool
+  ws_server.py        Standalone WebSocket server with SCRAM auth and batch dispatch
+  ws_codec.py         Binary frame codec (4-byte header + JSON payload)
+  encoding/
+    json.py           JSON v3/v4 encode/decode via orjson
+    zinc.py           Zinc text format encode/decode
+    trio.py           Trio tagged record format
+    csv.py            CSV export (encode-only, lossy)
+    scanner.py        Shared Zinc value scanning
+  filter/
+    ast.py            Filter AST nodes (Has, Missing, Cmp, And, Or, Path)
+    lexer.py          Filter expression tokenizer
+    parser.py         Recursive descent parser
+    eval.py           Filter evaluation against dicts/grids
+  storage/
+    protocol.py       StorageAdapter protocol (11 async methods)
+    memory.py         In-memory adapter for testing
+    redis.py          Redis + RediSearch + RedisTimeSeries adapter
+    timescale.py      PostgreSQL/TimescaleDB adapter via asyncpg
+  ontology/
+    defs.py           Def and Lib frozen dataclasses
+    namespace.py      Namespace container, symbol resolution
+    taxonomy.py       Subtype tree, tag inheritance
+    normalize.py      Normalization pipeline
+    reflect.py        Dict-to-def reflection engine
+```
+
+### Key Classes
+
+| Class | Module | Purpose |
+|-------|--------|---------|
+| `Client` | `client` | Async HTTP client with SCRAM auth and all Haystack ops |
+| `WebSocketClient` | `ws_client` | Persistent WebSocket client with batch and watch support |
+| `ReconnectingWebSocketClient` | `ws_client` | Auto-reconnecting WebSocket client with exponential backoff |
+| `WebSocketPool` | `ws_client` | Multiplexed channels over a single WebSocket connection |
+| `HaystackOps` | `ops` | Storage-backed server operation handler for all 13 ops |
+| `WebSocketServer` | `ws_server` | Standalone WebSocket server with SCRAM auth and push |
+| `Grid` | `grid` | Universal Haystack message format (immutable) |
+| `GridBuilder` | `grid` | Fluent builder for constructing grids |
+| `StorageAdapter` | `storage.protocol` | Protocol for pluggable storage backends |
+| `TLSConfig` | `tls` | TLS certificate configuration |
+| `MetricsHooks` | `metrics` | Optional observability callbacks |
+| `WatchState` | `watch` | Server-side watch delta computation |
+| `WatchAccumulator` | `watch` | Client-side watch delta merging |
+| `Namespace` | `ontology.namespace` | Resolved ontology with taxonomy queries |
+
+### Error Handling
+
+All client methods raise from a common exception hierarchy:
+
+```python
+from hs_py import HaystackError, CallError, AuthError, NetworkError
+
+# HaystackError         Base for all haystack-py errors
+#   CallError            Server returned an error grid
+#   AuthError            Authentication failure
+#   NetworkError         Transport-level failure
+```
+
+## Configuration
+
+### Docker Compose
+
+The included `docker/docker-compose.yml` provides a complete development stack:
+
+```bash
+docker compose -f docker/docker-compose.yml up -d
+```
+
+Services:
+
+| Service | Port | Description |
+|---------|------|-------------|
+| `server` | 8080 | FastAPI Haystack server with SCRAM auth |
+| `redis` | 6379 | Redis with RediSearch and RedisTimeSeries |
+| `timescaledb` | 5432 | TimescaleDB (PostgreSQL 16) |
+| `redis-tls` | 6380 | Redis with mTLS for TLS integration tests |
+
+Environment variables for the server:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `REDIS_URL` | `redis://redis:6379` | Redis connection URL |
+| `HAYSTACK_USER` | `admin` | SCRAM username |
+| `HAYSTACK_PASS` | `secret` | SCRAM password |
+
+### Seed Data
+
+The `_data/` directory contains Project Haystack example building datasets in JSON v4 format:
+
+- **Alpha** — 2,032 entities (1 site, 184 equips, 1,846 points)
+- **Bravo** — 1,077 entities (1 site, 149 equips, 918 points)
+
+These are loaded automatically by the Docker server on startup.
+
+## Testing
+
+```bash
+make test          # 1,200+ unit tests
+make lint          # ruff check + format verification
+make typecheck     # mypy strict
+make check         # lint + typecheck + test (all of the above)
+make coverage      # tests with coverage report
+make fix           # auto-fix lint/format issues
+make docs          # sphinx-build
+```
+
+### Docker Integration Tests
+
+End-to-end testing against real services with full SCRAM authentication:
+
+```bash
+make docker-server         # Start Redis + FastAPI server stack
+make docker-test-e2e       # 69 end-to-end tests (HTTP, WebSocket, auth, history, watch)
+make docker-server-clean   # Tear down server stack
+```
+
+### Storage Backend Tests
+
+```bash
+make docker-test              # Redis adapter integration tests
+make docker-test-tls          # Redis mTLS integration tests
+make docker-test-timescale    # 122 TimescaleDB integration tests
+```
+
+### Cleanup
+
+```bash
+make docker-clean             # Remove Redis containers
+make docker-clean-timescale   # Remove TimescaleDB containers
+```
+
+## Requirements
+
+- Python >= 3.13
+- [aiohttp](https://docs.aiohttp.org/) >= 3.10
+- [orjson](https://github.com/ijl/orjson) >= 3.10
+- [cryptography](https://cryptography.io/) >= 42.0
+- [websockets](https://websockets.readthedocs.io/) >= 14.0
+- Optional: [FastAPI](https://fastapi.tiangolo.com/) + [Redis](https://redis.io/) for server mode
+- Optional: [asyncpg](https://magicstack.github.io/asyncpg/) for TimescaleDB backend
+- Docker and Docker Compose for integration tests
+
+## License
+
+MIT

haystack_py-0.1.3.dist-info/RECORD

@@ -0,0 +1,49 @@
+hs_py/__init__.py,sha256=1a1NH5CbNGKTeDbwx4SdqobDoR_-eh-0rRmf0d-AgXw,3782
+hs_py/__main__.py,sha256=MQtHV1A3od6WtqwGPYd3Ya9m_KJrnPVBks0TpAvjY6o,3793
+hs_py/_scram_core.py,sha256=UquYTt96USmSn85fuwwq-5YY4PTD-tygkDqFpiFc65Q,9845
+hs_py/auth.py,sha256=3aVD_tnjsu3nar4yTUB9M9w4lDA7YCXFbxlsQ4tsiak,13776
+hs_py/auth_types.py,sha256=fBTJFokvodz4ar2645SeYHOa07_47biJUyrOzRYNwkc,3660
+hs_py/client.py,sha256=Fr9wrAQBW3lQ1hHykl7sjNs62dW4-3xoi5n37FNhz0w,22654
+hs_py/content_negotiation.py,sha256=UGULngWqCcHxL2YLO5iQN5XNFRhjd6jZ30_jLPQVMlE,4577
+hs_py/convert.py,sha256=RTkINlzsKF8rHYgbip78MvbGH3zJcd9hmVBmeazUP64,2911
+hs_py/errors.py,sha256=hKW_rWe_RK8_JdR5Qe7gbmEO8WLGv1GDHX9Dp22HoYU,1330
+hs_py/fastapi_server.py,sha256=aRysIRNUhu3ZCBIRuUFQU6F2DIEIazjeNAftqjIcDtA,18273
+hs_py/grid.py,sha256=VDHqB43uA1kcZJzqbFyMoNDgZ9SRjeMllW8j7ZV41ME,6153
+hs_py/kinds.py,sha256=sbI5ziUKakktb39W9xSA15npaK7RHE0sF9hku1jtcZQ,7451
+hs_py/metrics.py,sha256=_tHSrAqbYUls_D2AOHvLR78IfLqmDiV5FDlnspRhjFw,2518
+hs_py/ops.py,sha256=cb7JtvECcbbf5q9OLeJEbrEWXLm7MHaO6shvnx9Rlsw,15300
+hs_py/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hs_py/redis_ops.py,sha256=XUJCo3gUeuesT4qoba-iJHJAYl0S6VTH9SyWs-Wk2Y0,4469
+hs_py/tls.py,sha256=Yk6-UR1jPigNBq4mKDSstSu_CjflyAc-tvzbsENjO10,11056
+hs_py/watch.py,sha256=8n0qVxtv5GMpuHcKEiZbzyH29oJ7P9FgUi00n-gJ7SI,6501
+hs_py/ws.py,sha256=CswvUPClez3h72Fuy8OzP0x0Al3B_VslHmeEi0MiKSo,14107
+hs_py/ws_client.py,sha256=N7QeU0BonL-YJuMU9J-P8YO1RPcPvT4s4PUauhZyN70,54310
+hs_py/ws_codec.py,sha256=rSQ5fODumoP2m3B5pxuFVbX7X5m5oIDcetY6WBsqUpE,4281
+hs_py/ws_server.py,sha256=hMNGNETIsojYapDZEguR2iTXdDhEJyMzYgne5B3CpXo,19670
+hs_py/encoding/__init__.py,sha256=xd40h674PlWQ-86_VDwrnYyOvDGkBfIvZJp0Vkx1tLk,1046
+hs_py/encoding/csv.py,sha256=8_JNj7-s8EFTEO-z3tdUXvGfuQFoN0poJQGJO2dbczU,2929
+hs_py/encoding/json.py,sha256=Y0qu52AQKvfrQpbmUTSIsj3gECws8KQFqgNkjE-I2YM,20421
+hs_py/encoding/scanner.py,sha256=Qy7n6V7M7T26qOa0e7KlD8-ttBeVFiexCHnkm-o0BOA,18771
+hs_py/encoding/trio.py,sha256=J2Z_C3jo3Q_FcL1a6ogWFK-e3iBF4CRDyhV-J4LdDwU,9062
+hs_py/encoding/zinc.py,sha256=WkZsm4lvkjLXRNHExSAeIXVWjEkzP_50P-hXWb4ogJ8,8606
+hs_py/filter/__init__.py,sha256=hEfsw8y67NDeBVwBBXU7N-vl6WDUWhvEMRXgIg5A1po,738
+hs_py/filter/ast.py,sha256=TQv17hDvMNELiiG942qB8mL6DjGqrOsMaQcqzyroU9I,2339
+hs_py/filter/eval.py,sha256=HJ0OktQEmUxGBV2EcwCqumzVsSbF2etEq3n0n-OZ-Ro,5662
+hs_py/filter/lexer.py,sha256=FclM5FWJUdCz1-usDSVLDMJOUOo-btL7xFz8yi0bh-8,10045
+hs_py/filter/parser.py,sha256=5tUABoOGL-rdKSoCet8Io0ZUYivvBrnYJHOlLlTcyRo,4889
+hs_py/ontology/__init__.py,sha256=iDU8t6wTj8lbyXyoSepLHngW8sw79GDHyVt9nwnw6qQ,1514
+hs_py/ontology/defs.py,sha256=VPbo1F6VYmbUkmycFJj2BrMA7bwFaCuT7vWKLXhP8aQ,4214
+hs_py/ontology/namespace.py,sha256=VwMdUB8YbYBHyn1ORSTp7iNZjoJUZPi_Cc70POcvleQ,8673
+hs_py/ontology/normalize.py,sha256=ks3y60UAHbjxpMYD32Llz6LexyrM8Biz5TTFovwI0nM,4803
+hs_py/ontology/rdf.py,sha256=3Ii3ABSF5T6p0SZwLM3HYBlU9wB7Gor11C_rWDWt4DU,3975
+hs_py/ontology/reflect.py,sha256=n20mtULp8hrq4nMEnGY5GFkm47-VcvJ7niGgNAF6wuE,3424
+hs_py/ontology/taxonomy.py,sha256=jLlFy6ELKZNg4AVFxqXPvvmjdEYk7k37Ms9uopEbI40,3307
+hs_py/storage/__init__.py,sha256=4h4lVreYnOND_YyyDQHR1OEqITzBAj9qrMUCgzlRIiA,942
+hs_py/storage/memory.py,sha256=3DLOaQaXDCMgNxca_iZrXTQZ_pfVlgNri2Ch5G_Iq6k,11937
+hs_py/storage/protocol.py,sha256=axFXSoAqjvEOOOqYB2XApNdfIilwqVmVXJ3avRBMnMU,5874
+hs_py/storage/redis.py,sha256=hERp5OI6dPq6_eKqkxdl5QGs77GdmWqx8Y8vYF6AqPg,28289
+hs_py/storage/timescale.py,sha256=EZx_XvOZkMkHiUCaps6yoXLgTm1BBJmK8ZYpWAnMePk,29827
+haystack_py-0.1.3.dist-info/METADATA,sha256=YkMiw1tRnounuxeNUx8Efb8FRKhZ90-EcXEt0GkICr0,15792
+haystack_py-0.1.3.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+haystack_py-0.1.3.dist-info/licenses/LICENSE,sha256=3GO_-MGsYcCdBLOP5qFVRUCgfAKrPLNEG7zN8JaauXc,1069
+haystack_py-0.1.3.dist-info/RECORD,,

haystack_py-0.1.3.dist-info/WHEEL

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

haystack_py-0.1.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Justin Scott
+
+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.

hs_py/__init__.py

@@ -0,0 +1,160 @@
+"""hs-py — Async Project Haystack client library for Python."""
+
+__version__ = "0.1.3"
+
+from hs_py.auth_types import (
+    Authenticator,
+    CertAuthenticator,
+    ScramCredentials,
+    SimpleAuthenticator,
+)
+from hs_py.client import Client
+from hs_py.convert import grid_to_pythonic
+from hs_py.encoding import JsonVersion
+from hs_py.errors import AuthError, CallError, HaystackError, NetworkError
+from hs_py.filter import ParseError, evaluate, evaluate_grid, parse
+from hs_py.grid import Col, Grid, GridBuilder
+from hs_py.kinds import (
+    MARKER,
+    NA,
+    REMOVE,
+    Coord,
+    Marker,
+    Na,
+    Number,
+    Ref,
+    Remove,
+    Symbol,
+    Uri,
+    XStr,
+)
+from hs_py.metrics import MetricsHooks
+from hs_py.ontology.rdf import export_jsonld, export_turtle
+from hs_py.ops import HaystackOps
+from hs_py.tls import (
+    TLSConfig,
+    build_client_ssl_context,
+    build_server_ssl_context,
+    extract_peer_cn,
+    extract_peer_sans,
+    generate_test_certificates,
+)
+from hs_py.watch import WatchAccumulator, WatchState
+from hs_py.ws import HaystackWebSocket
+from hs_py.ws_client import (
+    ChannelClient,
+    ReconnectingWebSocketClient,
+    WebSocketClient,
+    WebSocketPool,
+)
+from hs_py.ws_codec import (
+    OP_CODES,
+    decode_binary_frame,
+    encode_binary_push,
+    encode_binary_request,
+    encode_binary_response,
+)
+from hs_py.ws_server import WebSocketServer
+
+
+def __getattr__(name: str) -> object:
+    if name == "RedisOps":
+        from hs_py.redis_ops import RedisOps
+
+        return RedisOps
+    if name == "RedisAdapter":
+        from hs_py.storage.redis import RedisAdapter
+
+        return RedisAdapter
+    if name == "create_redis_client":
+        from hs_py.redis_ops import create_redis_client
+
+        return create_redis_client
+    if name == "create_fastapi_app":
+        from hs_py.fastapi_server import create_fastapi_app
+
+        return create_fastapi_app
+    if name == "StorageAdapter":
+        from hs_py.storage.protocol import StorageAdapter
+
+        return StorageAdapter
+    if name == "InMemoryAdapter":
+        from hs_py.storage.memory import InMemoryAdapter
+
+        return InMemoryAdapter
+    if name == "TimescaleAdapter":
+        from hs_py.storage.timescale import TimescaleAdapter
+
+        return TimescaleAdapter
+    if name == "create_timescale_pool":
+        from hs_py.storage.timescale import create_timescale_pool
+
+        return create_timescale_pool
+    msg = f"module {__name__!r} has no attribute {name!r}"
+    raise AttributeError(msg)
+
+
+__all__ = [
+    "MARKER",
+    "NA",
+    "OP_CODES",
+    "REMOVE",
+    "AuthError",
+    "Authenticator",
+    "CallError",
+    "CertAuthenticator",
+    "ChannelClient",
+    "Client",
+    "Col",
+    "Coord",
+    "Grid",
+    "GridBuilder",
+    "HaystackError",
+    "HaystackOps",
+    "HaystackWebSocket",
+    "InMemoryAdapter",
+    "JsonVersion",
+    "Marker",
+    "MetricsHooks",
+    "Na",
+    "NetworkError",
+    "Number",
+    "ParseError",
+    "ReconnectingWebSocketClient",
+    "RedisAdapter",
+    "RedisOps",
+    "Ref",
+    "Remove",
+    "ScramCredentials",
+    "SimpleAuthenticator",
+    "StorageAdapter",
+    "Symbol",
+    "TLSConfig",
+    "TimescaleAdapter",
+    "Uri",
+    "WatchAccumulator",
+    "WatchState",
+    "WebSocketClient",
+    "WebSocketPool",
+    "WebSocketServer",
+    "XStr",
+    "__version__",
+    "build_client_ssl_context",
+    "build_server_ssl_context",
+    "create_fastapi_app",
+    "create_redis_client",
+    "create_timescale_pool",
+    "decode_binary_frame",
+    "encode_binary_push",
+    "encode_binary_request",
+    "encode_binary_response",
+    "evaluate",
+    "evaluate_grid",
+    "export_jsonld",
+    "export_turtle",
+    "extract_peer_cn",
+    "extract_peer_sans",
+    "generate_test_certificates",
+    "grid_to_pythonic",
+    "parse",
+]