pulse-data 0.2.2__py3-none-any.whl

inventzia/pulse/data/schemas/platform/heart_beat.py

@@ -0,0 +1,43 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later OR LicenseRef-Inventzia-Commercial
+# Copyright (c) 2013-2026 Magrino Bini, Paola Apruzzese, Inventzia Science and Technology Ltd.
+#
+# This file is part of pulse-data.
+#
+# pulse-data is dual-licensed:
+#   - Under the GNU Affero General Public License v3.0 or later (see LICENSE-AGPL-3.0).
+#   - Under a commercial license (see LICENSE-COMMERCIAL.txt).
+#     Contact operations@inventzia.com.
+#
+# THIS FILE IS GENERATED. DO NOT EDIT MANUALLY.
+# Source: schemas_yaml/platform/heartbeat.yaml
+# Regenerate: python schemas/schemas-generators/generate_python.py
+
+from __future__ import annotations
+from pydantic import BaseModel, ConfigDict, Field
+from typing import ClassVar, Optional
+
+
+class HeartBeat(BaseModel):
+    """
+    Periodic platform heartbeat produced by HeartBeatGateway. Actors subscribe to a heartbeat Topic to implement periodic behaviour (analytics windows, timeout checks) that fires at regular simulation-time intervals regardless of whether domain events arrive in that interval.
+    """
+
+    model_config = ConfigDict(extra="ignore", frozen=True)
+
+    TYPE_ID:      ClassVar[str] = "com.inventzia.pulse.data.schemas.platform.HeartBeat"
+    TYPE_VERSION: ClassVar[int] = 1
+
+    beat_key: str = Field(alias="beatKey")
+    """Heartbeat identifier. Typically a fixed label (e.g. "PERIODIC") or a group key when multiple independent heartbeat streams are needed"""
+    beat_time: int = Field(alias="beatTime")
+    """Scheduled beat time in epoch milliseconds"""
+
+    # -- Datum protocol ---------------------------------------------------
+
+    @property
+    def datum_key(self) -> str:
+        return self.beat_key
+
+    @property
+    def datum_time(self) -> int:
+        return self.beat_time

inventzia/pulse/data/schemas/platform/text_message.py

@@ -0,0 +1,45 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later OR LicenseRef-Inventzia-Commercial
+# Copyright (c) 2013-2026 Magrino Bini, Paola Apruzzese, Inventzia Science and Technology Ltd.
+#
+# This file is part of pulse-data.
+#
+# pulse-data is dual-licensed:
+#   - Under the GNU Affero General Public License v3.0 or later (see LICENSE-AGPL-3.0).
+#   - Under a commercial license (see LICENSE-COMMERCIAL.txt).
+#     Contact operations@inventzia.com.
+#
+# THIS FILE IS GENERATED. DO NOT EDIT MANUALLY.
+# Source: schemas_yaml/platform/text_message.yaml
+# Regenerate: python schemas/schemas-generators/generate_python.py
+
+from __future__ import annotations
+from pydantic import BaseModel, ConfigDict, Field
+from typing import ClassVar, Optional
+
+
+class TextMessage(BaseModel):
+    """
+    Generic carrier for a free-text string payload. The platform equivalent of a plain message — useful for diagnostics, echo/relay examples, and any actor or gateway that needs to move arbitrary text on a topic.
+    """
+
+    model_config = ConfigDict(extra="ignore", frozen=True)
+
+    TYPE_ID:      ClassVar[str] = "com.inventzia.pulse.data.schemas.platform.TextMessage"
+    TYPE_VERSION: ClassVar[int] = 1
+
+    msg_key: str = Field(alias="msgKey")
+    """Routing key for this message — e.g. a channel, source identifier, or logical stream name"""
+    msg_time: int = Field(alias="msgTime")
+    """Epoch milliseconds when the message was created"""
+    text: str
+    """The free-text payload"""
+
+    # -- Datum protocol ---------------------------------------------------
+
+    @property
+    def datum_key(self) -> str:
+        return self.msg_key
+
+    @property
+    def datum_time(self) -> int:
+        return self.msg_time

inventzia/pulse/data/schemas/provider.py

@@ -0,0 +1,45 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later OR LicenseRef-Inventzia-Commercial
+# Copyright (c) 2013-2026 Magrino Bini, Paola Apruzzese, Inventzia Science and Technology Ltd.
+#
+# This file is part of pulse-data.
+#
+# pulse-data is dual-licensed:
+#   - Under the GNU Affero General Public License v3.0 or later (see LICENSE-AGPL-3.0).
+#   - Under a commercial license (see LICENSE-COMMERCIAL.txt).
+#     Contact operations@inventzia.com.
+#
+# THIS FILE IS GENERATED. DO NOT EDIT MANUALLY.
+# Source: all schemas under schemas_yaml/
+# Regenerate: python schemas/schemas-generators/generate_python.py
+
+"""The datum-type provider (generated) for com.inventzia.pulse.data."""
+
+from inventzia.pulse.data.datum.provider import DatumTypeBinding
+from inventzia.pulse.data.schemas.common.vector_value import VectorValue
+from inventzia.pulse.data.schemas.marketdata.cdf_bar import CdfBar
+from inventzia.pulse.data.schemas.platform.heart_beat import HeartBeat
+from inventzia.pulse.data.schemas.platform.text_message import TextMessage
+
+
+class CoreDatumTypeProvider:
+    """Datum types contributed by com.inventzia.pulse.data, discovered via the SPI."""
+
+    def provider_id(self) -> str:
+        return "com.inventzia.pulse.data"
+
+    def spi_version(self) -> int:
+        return 1
+
+    def package_version(self) -> str:
+        return "0.2.2"
+
+    def bindings(self) -> "list[DatumTypeBinding]":
+        return [
+            DatumTypeBinding(VectorValue.TYPE_ID, VectorValue.TYPE_VERSION, VectorValue),
+            DatumTypeBinding(CdfBar.TYPE_ID, CdfBar.TYPE_VERSION, CdfBar),
+            DatumTypeBinding(HeartBeat.TYPE_ID, HeartBeat.TYPE_VERSION, HeartBeat),
+            DatumTypeBinding(TextMessage.TYPE_ID, TextMessage.TYPE_VERSION, TextMessage),
+        ]
+
+    def manifest(self):
+        return "pdm1|com.inventzia.pulse.data|com.inventzia.pulse.data.schemas.common.VectorValue:1:47a0adfbbf19dcd7614cdf985086a67531a2bc9f5d1d6c5a5a721e6ee753ba23;com.inventzia.pulse.data.schemas.marketdata.CdfBar:1:3e6e7e76fc16188671c3c7d8036490b6c78bebcfa9293998af6d286e1a0dabd8;com.inventzia.pulse.data.schemas.platform.HeartBeat:1:5e08970887ce4d3424a8228b3a8b83622ba72a50d628ea155ca390802451844c;com.inventzia.pulse.data.schemas.platform.TextMessage:1:bb0ccb451f6abf888d58d3bab5bd82fbf31feab607139de5db38644977f1383a"

inventzia/pulse/data/schemas/registry.py

@@ -0,0 +1,51 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later OR LicenseRef-Inventzia-Commercial
+# Copyright (c) 2013-2026 Magrino Bini, Paola Apruzzese, Inventzia Science and Technology Ltd.
+#
+# This file is part of pulse-data.
+#
+# pulse-data is dual-licensed:
+#   - Under the GNU Affero General Public License v3.0 or later (see LICENSE-AGPL-3.0).
+#   - Under a commercial license (see LICENSE-COMMERCIAL.txt).
+#     Contact operations@inventzia.com.
+#
+# THIS FILE IS GENERATED. DO NOT EDIT MANUALLY.
+# Source: all schemas under schemas_yaml/
+# Regenerate: python schemas/schemas-generators/generate_python.py
+
+"""Self-describing decode support: TYPE_ID -> generated model class."""
+
+from inventzia.pulse.data.schemas.marketdata.cdf_bar import CdfBar
+from inventzia.pulse.data.schemas.platform.heart_beat import HeartBeat
+from inventzia.pulse.data.schemas.platform.text_message import TextMessage
+from inventzia.pulse.data.schemas.common.vector_value import VectorValue
+
+
+REGISTRY: dict[str, type] = {
+    CdfBar.TYPE_ID: CdfBar,
+    HeartBeat.TYPE_ID: HeartBeat,
+    TextMessage.TYPE_ID: TextMessage,
+    VectorValue.TYPE_ID: VectorValue,
+}
+
+
+def class_for(type_id: str) -> type:
+    """Return the model class registered for a TYPE_ID."""
+    try:
+        return REGISTRY[type_id]
+    except KeyError:
+        raise KeyError(f"Unknown TYPE_ID: {type_id!r}") from None
+
+
+def type_id_of(datum) -> str:
+    """Return the TYPE_ID of a datum, verified against the registry.
+
+    Encoding must not emit a tagged envelope for a class that is not the
+    registered binding for its declared TYPE_ID, or a receiver could get a
+    typeId no runtime can decode. Mirrors the Java DatumTypeRegistry check.
+    """
+    cls = type(datum)
+    type_id = getattr(cls, "TYPE_ID", None)
+    if REGISTRY.get(type_id) is not cls:
+        raise KeyError(
+            f"Unregistered datum type: {cls.__name__} (TYPE_ID {type_id!r})")
+    return type_id

pulse_data-0.2.2.dist-info/METADATA

@@ -0,0 +1,259 @@
+Metadata-Version: 2.4
+Name: pulse-data
+Version: 0.2.2
+Summary: YAML-sourced data schemas and the Datum routing contract for the Pulse platform (one namespace, Java + Python).
+Author-email: Magrino Bini <operations@inventzia.com>, Paola Apruzzese <operations@inventzia.com>
+Maintainer-email: "Inventzia Science and Technology Ltd." <operations@inventzia.com>
+License-Expression: AGPL-3.0-or-later OR LicenseRef-Inventzia-Commercial
+Project-URL: Homepage, https://inventzia.com
+Project-URL: Repository, https://github.com/inventzia-sci-tech/pulse-data
+Project-URL: Changelog, https://github.com/inventzia-sci-tech/pulse-data/blob/main/CHANGELOG.md
+Keywords: pulse,schemas,pydantic,algorithmic-trading,event-driven
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE-AGPL-3.0
+License-File: LICENSE-COMMERCIAL.txt
+License-File: NOTICE
+Requires-Dist: pydantic<3,>=2
+Provides-Extra: generator
+Requires-Dist: pyyaml>=6; extra == "generator"
+Requires-Dist: datamodel-code-generator>=0.25; extra == "generator"
+Dynamic: license-file
+
+# pulse-data
+
+**pulse-data** is the single source of truth for the data types that flow across the Pulse
+platform. Every event type is defined once in YAML and code-generated into strongly-typed,
+immutable classes for both Java and Python. There is no hand-written serialisation code and no
+way for the two language bindings to drift apart — they are projections of the same schema.
+
+A consumer of pulse-data gets two things: a small, stable **routing contract** (`Datum`) that the
+transport layer depends on, and a growing set of **generated data classes** that implement it.
+
+This repository is deliberately narrow. It contains *only* the data definition — the contract,
+the schemas, and the generators. It pulls no pandas, no SQLAlchemy, no Airflow. Anything that
+*uses* the data (ingestion pipelines, storage backends, orchestration, shared helpers) lives in
+**[pulse-utils](https://github.com/inventzia-sci-tech/pulse-utils)** and depends on pulse-data,
+never the other way round.
+
+---
+
+## What lives here
+
+| Area | Path | What it is |
+|------|------|-----------|
+| Routing contract | `datum/` | Hand-written `Datum` interface (Java) and `Protocol` (Python). The stable API everything else conforms to. |
+| JSON serializer | `datum/` | `DatumCodec` (Java) and `datum/codec.py` (Python) — the canonical, shared serializer for `Datum` types (see below). |
+| Schema sources | `schemas/schemas_yaml/` | YAML definitions — the single source of truth. |
+| Generated Java | `schemas/schemas_java/` | Immutable Java `record` classes under `com.inventzia.pulse.data.schemas`. Build artefact; do not edit. |
+| Generated Python | `src/inventzia/pulse/data/schemas/` | Pydantic v2 models under `inventzia.pulse.data.schemas` (mirrors Java), in the installable `src/` tree. Build artefact; do not edit. |
+| Type registry | both | Composite `DatumTypeRegistry` (Java) / `datum/registry.py` (Python): TYPE_ID ↔ class, built from the core provider plus discovered extension providers (the `DatumTypeProvider` SPI), for self-describing decode. |
+| Generators | `schemas/schemas-generators/` | `generate_java.py`, `generate_python.py`. |
+
+Everything here is light: the Java side compiles to a small jar (Jackson + JSpecify only); the
+Python side needs just PyYAML, datamodel-code-generator, and Pydantic.
+
+---
+
+## Core idea: schema → routing-aware data class
+
+A schema is plain JSON-Schema (draft-07) in YAML, with two pulse-specific annotations that mark
+which fields carry routing meaning:
+
+```yaml
+# schemas/schemas_yaml/marketdata/cdf_bar.yaml
+$id: "com.inventzia.pulse.data.schemas.marketdata.CdfBar"
+title: CdfBar
+type: object
+properties:
+  symb:
+    type: string
+    x-datum-key: true        # this field is the routing key
+  timestamp:
+    type: integer
+    format: int64
+    x-datum-time: true       # this field is the logical event time
+  op:    { type: number, format: decimal }
+  # ... more fields ...
+required: [symb, timestamp, op]
+```
+
+From this, the generators produce classes that implement the `Datum` contract by delegating to the
+annotated fields:
+
+**Java** (`schemas_java/.../CdfBar.java`) — an immutable record:
+```java
+public record CdfBar(String symb, long timestamp, BigDecimal op /* ... */)
+        implements Datum {
+    public static final String TYPE_ID      = "com.inventzia.pulse.data.schemas.marketdata.CdfBar";
+    public static final int    TYPE_VERSION = 1;
+    @Override public String getDatumKey()  { return symb; }
+    @Override public long   getDatumTime() { return timestamp; }
+}
+```
+
+**Python** (`src/inventzia/pulse/data/schemas/marketdata/cdf_bar.py`) — a Pydantic v2 model
+satisfying the `Datum` protocol:
+```python
+class CdfBar(BaseModel):
+    TYPE_ID:      ClassVar[str] = "com.inventzia.pulse.data.schemas.marketdata.CdfBar"
+    TYPE_VERSION: ClassVar[int] = 1
+    symb: str
+    timestamp: int
+    # ...
+    @property
+    def datum_key(self) -> str:  return self.symb
+    @property
+    def datum_time(self) -> int: return self.timestamp
+```
+
+---
+
+## Design decisions
+
+- **YAML is the only source of truth.** Field definitions exist in exactly one place. Java and
+  Python are generated, never hand-edited. Regenerate after every schema change.
+
+- **`$id` is the type identity.** Each schema's `$id` is the fully-qualified class name and becomes
+  the `TYPE_ID` constant in both languages — the single discriminator used for routing and
+  deserialisation. There is no separate numeric id to keep in sync.
+
+- **The `Datum` contract is minimal.** Two methods — `getDatumKey()` and `getDatumTime()` — are all
+  the transport layer needs to route and time-order data. The schema author decides which domain
+  fields fulfil them via `x-datum-key` / `x-datum-time`. Nothing else about the payload is exposed
+  to the infrastructure.
+
+- **Data classes are genuinely immutable.** Java records take defensive unmodifiable copies of any
+  list fields and reject null required fields in their compact constructor; Pydantic models are
+  `frozen` with tuple (not list) sequences. A value on the bus cannot be mutated by one consumer and
+  observed changed by another, nor become invalid after construction.
+
+- **JSON is the wire format.** Java (Jackson) and Python (Pydantic) serialise to and from the same
+  JSON, so a value produced in one language is consumed verbatim in the other.
+
+- **Serialization is owned here, not by callers.** Because pulse-data owns the types and schemas,
+  it also owns how a `Datum` becomes JSON. `DatumCodec` is the canonical serializer, a shared
+  singleton (`DatumCodec.instance()`), with `toJson(Datum)` / `fromJson(json, type)` as its whole
+  surface. It configures the JSON policy *once* for every field type the schemas use — JSR-310
+  `java.time` written as ISO-8601, `BigDecimal` for exact decimals, unknown properties ignored on
+  read for forward compatibility — and hides the underlying engine (Jackson) entirely. Consumers
+  never construct or pass a JSON mapper; downstream code (e.g. pulse-beacon's gateways) uses the
+  singleton and never references Jackson.
+
+  Two forms are offered. **Type-directed** (`toJson` / `fromJson(json, Class)`) when the caller
+  knows the concrete class — e.g. it knows a topic's payload type. **Self-describing** (`toTaggedJson`
+  / `fromTaggedJson`) wraps the value in an envelope `{"typeId": "<TYPE_ID>", "payload": {…}}`, so a
+  receiver can recover the type from the message itself wherever it isn't known ahead of time — the
+  in-process cross-language bridge, and later the socket/ZMQ transport. The class is resolved through
+  a composite `TYPE_ID → class` registry (`DatumTypeRegistry` in Java, `datum/registry.py` in
+  Python), built from the core provider plus any discovered extension providers (the
+  `DatumTypeProvider` SPI). The same envelope is produced and consumed identically in both languages.
+
+- **Forward compatibility is symmetric across languages.** Both bindings tolerate unknown fields on
+  read, so a newer producer that adds a field does not break an older consumer in either language:
+  Java disables `FAIL_ON_UNKNOWN_PROPERTIES`, and generated Python models use
+  `model_config(extra="ignore")`. This only covers *additive* changes; removals, renames, and type
+  changes are breaking and must bump `TYPE_VERSION`, so evolution within a major version is
+  additive-only by discipline. Because "ignore" silently drops drift (it would hide, say, one side
+  emitting a field the other does not), a cross-language round-trip test
+  (`pulse-beacon .../tests/test_codec_cross_language_parity.py`) asserts the tagged envelope is
+  identical after a Java↔Python round-trip — the loud drift detector `extra="forbid"` used to give.
+
+- **Python uses structural typing.** The Python `Datum` is a `Protocol`; generated models satisfy
+  it by exposing `datum_key` / `datum_time` properties — no inheritance, no import coupling.
+
+---
+
+## Adding a new data type
+
+### In pulse-data itself (a core type)
+
+1. Create a YAML schema under `schemas/schemas_yaml/<area>/`, with a unique `$id`, a `title`
+   (becomes the class name), and exactly one `x-datum-key` and one `x-datum-time` field.
+2. Regenerate both bindings:
+   ```bash
+   cd schemas/schemas-generators
+   conda run -n pulse python generate_java.py
+   conda run -n pulse python generate_python.py
+   ```
+3. Commit the YAML **and** the regenerated Java/Python output.
+
+See [`schemas/schemas-generators/readme.md`](https://github.com/inventzia-sci-tech/pulse-data/blob/main/schemas/schemas-generators/readme.md) for generator
+options (paths, dry-run, verbose).
+
+### From another package (an extension, via the `DatumTypeProvider` SPI)
+
+Pulse ships a fixed set of core datum types (market bars, heartbeats, text messages), but an
+adopter's domain rarely fits those alone. Say an IoT company adopts Pulse as the event-driven
+transport layer for its device fleet: it needs to move its own specialized payloads (sensor
+telemetry, device state, actuator commands), each with fields specific to its hardware. Because
+every Pulse event is routed across the Java engine and the Python strategies and must decode
+identically on both sides, such a payload cannot be an ad-hoc class in one language; it has to be a
+first-class, self-describing `Datum` that both runtimes agree on. The SPI is how a downstream
+package adds exactly that, on its own release cadence, without forking or modifying pulse-data.
+
+A package contributes its custom `Datum` types by implementing the `DatumTypeProvider` Service
+Provider Interface and declaring the types it adds in that provider's `bindings()` (each a type id,
+version, and `Datum` class). The implementation is registered declaratively via a
+`META-INF/services/…DatumTypeProvider` file bundled in the package's jar (and, in Python, an
+`inventzia.pulse.datum_types` entry point). At runtime these providers are discovered by
+`java.util.ServiceLoader`, which scans every jar on the classpath for that registration and loads
+the listed provider classes. The discovery is performed once, explicitly, during engine
+initialization (`DatumTypeRegistry.discoverProviders()`), which seeds the core provider and merges
+in the discovered extensions into a single validated, frozen registry.
+
+The extension owns its schema and generated bindings (it runs the same generators with its own
+`--provider-id`/`--provider-class`), so pulse-data and pulse-beacon are never edited to add the
+type. See the worked, runnable example at `examples/pulse-ext-example` (in pulse-beacon), which
+defines an `ExtendedBar` datum and flows it through the engine end to end in both languages.
+
+---
+
+## Environment
+
+The Python generators run in the minimal conda environment defined by
+[`py_environment.yml`](https://github.com/inventzia-sci-tech/pulse-data/blob/main/py_environment.yml):
+
+```bash
+conda env create -f py_environment.yml
+conda activate pulse
+```
+
+This creates the shared `pulse` env (base layer). Working across the stack? pulse-beacon enriches
+the same env with a JDK + Maven + the JPype bridge — see its README.
+
+Java sources (the `Datum` interface and generated records) build with Maven via
+[`pom.xml`](https://github.com/inventzia-sci-tech/pulse-data/blob/main/pom.xml); Java 17+.
+
+---
+
+## Licensing
+
+Dual-licensed:
+
+- **Open Source (AGPL v3.0 or later)** — see [`LICENSE-AGPL-3.0`](https://github.com/inventzia-sci-tech/pulse-data/blob/main/LICENSE-AGPL-3.0).
+- **Commercial License** — see [`COMMERCIAL.md`](https://github.com/inventzia-sci-tech/pulse-data/blob/main/COMMERCIAL.md) for the summary and
+  [`LICENSE-COMMERCIAL.txt`](https://github.com/inventzia-sci-tech/pulse-data/blob/main/LICENSE-COMMERCIAL.txt) for the binding terms.
+
+Contact operations@inventzia.com for commercial licensing.
+
+## Contributing
+
+By submitting a contribution you agree to [`CLA.md`](https://github.com/inventzia-sci-tech/pulse-data/blob/main/CLA.md), including the Developer Certificate
+of Origin sign-off and the dual-licensing grant. CI enforces DCO sign-off on every PR commit.
+
+## Security
+
+Report vulnerabilities privately per [`SECURITY.md`](https://github.com/inventzia-sci-tech/pulse-data/blob/main/SECURITY.md). Do not open public issues for
+security problems.
+
+## Trademarks
+
+"Pulse" and "Inventzia" are trademarks of Inventzia Science and Technology Ltd. The licenses for
+this software do not grant any rights to use these trademarks.

pulse_data-0.2.2.dist-info/RECORD

@@ -0,0 +1,19 @@
+inventzia/pulse/data/__init__.py,sha256=97IR_BdtQ5gtjdHygDlPm1mBoHiNW2hULuzcKgk0TOM,965
+inventzia/pulse/data/datum/__init__.py,sha256=iOnMP53RZL6yqsUhFMCAT1S6gdU17wozYwDVfp0uVi0,866
+inventzia/pulse/data/datum/codec.py,sha256=kSIqxn8MlmbFY0H05WbKNu9Jb5gIYejSiLZQml4hC7o,3956
+inventzia/pulse/data/datum/datum.py,sha256=GRJL0tdXjHIgf0izpnZc3jsBf9kmLDAZKU_8zdErhQA,1769
+inventzia/pulse/data/datum/provider.py,sha256=msBbYF14oDIQRQbBe5wLYwFwWgxACyASvmODXCYQoR0,2564
+inventzia/pulse/data/datum/registry.py,sha256=DpFB3duuVGAfO5y7wFCQfvI2r36OBWKSOKHkoOBeOog,11826
+inventzia/pulse/data/schemas/provider.py,sha256=GFyAQ67McluvrzCQIfMgwEXhe8PvELdikm9cA13TwdM,2297
+inventzia/pulse/data/schemas/registry.py,sha256=onLG10Wtzz7IJoenikLnlGaJm6WB4PI5A8GD_OR1W0c,1916
+inventzia/pulse/data/schemas/common/vector_value.py,sha256=FLhUsSI6sq46yKu7vwD1AXXRUPtarODzfateL5ksV8U,2132
+inventzia/pulse/data/schemas/marketdata/cdf_bar.py,sha256=uJj4N_KEpZL_pgbBA3dBCdwhPDZnAhoDTFm2Zd4ynCs,2213
+inventzia/pulse/data/schemas/platform/heart_beat.py,sha256=FDgdRlL3tYQoOIZm8l69atnYk_jEDp2rD_70tPI7LHo,1748
+inventzia/pulse/data/schemas/platform/text_message.py,sha256=bdUpBiYRfk6OAsaY1i1j04DQPUdDxysmMaM-joGNfU8,1696
+pulse_data-0.2.2.dist-info/licenses/LICENSE-AGPL-3.0,sha256=wus861f4rHEuwRIuzANysgaYQlN-aJRNYGyYQ-oun7o,34824
+pulse_data-0.2.2.dist-info/licenses/LICENSE-COMMERCIAL.txt,sha256=iRXI0mDkIpAxxjAS8Yk6iBpAOqEjwp1C991m48KBR1c,897
+pulse_data-0.2.2.dist-info/licenses/NOTICE,sha256=x7uiR8sNQuv3NqQkTDfzl5znhQfKLqZz3uefNrb4ruc,695
+pulse_data-0.2.2.dist-info/METADATA,sha256=xJ_vJB10YjpUPEkX2K4Va0CqW9t3c-zdHLEhKBXMtEA,13748
+pulse_data-0.2.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pulse_data-0.2.2.dist-info/top_level.txt,sha256=xEqvAhkOXMpZYeRA8teLRiLFkleq7xBq3GOHCuruin8,10
+pulse_data-0.2.2.dist-info/RECORD,,

pulse_data-0.2.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+