Skip to main content


Sinapsis
Sinapsis Protocol

Versioned Universal Data Transport for Sinapsis.

sinapsis-protocol implements Universal Data Transport (UDT): a Python protocol for serializing, transporting, and reconstructing Sinapsis DataContainer objects and their nested packets.

The protocol standardizes the container and wire representation while allowing individual payloads to use the format best suited to their data. MessagePack is the common wire format; NumPy, Torch, Apache Arrow, Protobuf, or an application-defined representation can be used within a payload, without replacing the DataContainer boundary.

Core principle: Standardize the container. Optimize the payload.

DataContainer and packet types belong to sinapsis-core and are exposed through the stable sinapsis.data_transport interface. sinapsis-protocol is responsible for their transport representation. It is not a general-purpose Python object serializer and does not implicitly serialize arbitrary Python classes.

Why this exists

Sinapsis data may cross Agent, process, worker, or service boundaries. Its transport contract needs to be:

  • Recursive: containers hold packet dataclasses, which can themselves hold structured values.
  • Versioned: the wire protocol and registered data types have explicit versions.
  • Binary-friendly: arrays and other binary payloads are transmitted without converting them into JSON lists.
  • Extensible: applications can register dataclass types and leaf/payload adapters.
  • Artifact-aware: large payloads may be stored separately and referenced by ArtifactRef.
  • Bounded: decoding and encoding impose configurable limits on structure and payload sizes.
  • Safe by design: no automatic pickle or cloudpickle fallback, and no dynamic import of arbitrary wire types.
  • Dependency-light: specialised adapters are optional and loaded when needed.
  • Format-agnostic at the boundary: payload representation can change without changing the DataContainer contract.

Why binary transport matters

AI and ML workloads frequently exchange arrays, tensors, images, audio, and tabular data, rather than just small text objects. The cost of converting those payloads into a generic interchange format can become significant when Templates exchange data repeatedly or stream results at high frequency.

Consider a NumPy float32 array with shape (1024, 1024). Its numerical content occupies 4 MiB as raw values. Turning it into a JSON array would require expanding a million values into decimal text, allocating a much larger intermediate representation in many cases, parsing those strings on receipt, and reconstructing the original dtype and shape. JSON is useful for human-readable configuration and API metadata, but it is not an efficient default for large numerical payloads.

sinapsis-protocol instead separates structure from content:

  • MessagePack carries the versioned container structure, packet fields, and typed payload descriptors.
  • NumPy arrays are encoded as contiguous binary bytes plus dtype, shape, and layout metadata.
  • Torch tensors use a binary representation and the metadata required for reconstruction.
  • Pandas / Polars tables use Apache Arrow IPC, preserving a columnar binary interchange format rather than converting each row into JSON objects.
  • Bytes, strings, paths, and custom types follow their respective core representations or explicitly registered codecs.

The receiver uses the descriptor to choose the correct decoder and reconstruct the supported Python value. The outer DataContainer remains the same regardless of the payload codec.

JSON-oriented numerical transport             Sinapsis UDT
------------------------------------          ---------------------------------
array → Python numbers → JSON text             array → binary bytes + dtype/shape
      → parse numbers → rebuild array                → MessagePack metadata
                                                    → rebuild typed array

Why it helps: less numeric-to-text conversion, fewer large temporary objects, and less time spent encoding and parsing payloads. That matters for real-time video, high-throughput inference, time-series streams, and distributed model training. Payload size, CPU cost, copying, and network latency all affect the result; this is a design choice, not a promise of zero-copy operation or a fixed speedup. For example, adapters may make an array contiguous or move a tensor to CPU memory before encoding.

Keep the data contract stable, not every payload format identical

A Torch tensor does not need to become a list simply because a downstream Template uses NumPy, and a DataFrame does not need to be converted to a list of dictionaries for transport. Each codec preserves the useful native binary representation and type metadata as far as its implementation allows. Compatibility is enforced at the container and codec boundaries, rather than by forcing every library into the least expressive format.

Architecture

flowchart TD
    A[Sinapsis DataContainer] --> B[Recursive dataclass walker]
    B --> C[Nested DataPackets / dataclasses]
    C --> D{Payload}

    D -->|NumPy| E[NumPy payload codec]
    D -->|Torch| F[Torch payload codec]
    D -->|Pandas / Polars| G[Arrow payload codec]
    D -->|bytes / string / path| H[Core payload representation]
    D -->|Protobuf / custom type| I[Registered payload codec]

    E --> J[Encoded payload]
    F --> J
    G --> J
    H --> J
    I --> J

    J --> K[DataContainer wire representation]

    K --> L{Payload size}
    L -->|small| M[Inline payload]
    L -->|large| N[ArtifactRef]

    M --> O[Versioned MessagePack wire format]
    N --> O

    O --> P[Wire representation]
    P --> Q[Transport]

    Q --> R[Deserializer]
    R --> S[Trusted dataclass / payload codec registry]
    S --> T[Reconstructed DataContainer]

Protobuf and other specialised formats are payload codecs. They encode individual payloads inside packets; they do not bypass the generic UDT container or its MessagePack envelope.

The generic path is:

DataContainer
    ↓
recursive dataclass walker
    ↓
nested packet dataclasses
    ↓
leaf-value dispatch
    ↓
typed payload representation / inline bytes / ArtifactRef
    ↓
versioned MessagePack envelope
    ↓
transport
    ↓
registered decoding and reconstruction

A specialised application may deliberately choose a separate, fixed contract:

Application-specific contract
    ↓
Protobuf schema
    ↓
Protobuf bytes

That is appropriate when both endpoints explicitly agree on a fixed schema and do not require the general DataContainer protocol. It is a different choice from embedding a Protobuf payload inside UDT.

Installation

Requires Python 3.13+. Install directly from the standard Python package index:

uv pip install sinapsis-protocol
# or
pip install sinapsis-protocol

Optional payload adapters:

uv pip install 'sinapsis-protocol[numpy]'
uv pip install 'sinapsis-protocol[torch]'
uv pip install 'sinapsis-protocol[pandas]'
uv pip install 'sinapsis-protocol[polars]'
uv pip install 'sinapsis-protocol[cv2]'

# All bundled optional adapters
uv pip install 'sinapsis-protocol[all]'

msgpack is a required dependency. Optional libraries are not required when transferring ordinary container metadata, text, or bytes.

Basic usage

The main entry points serialize and deserialize a Sinapsis container:

from sinapsis.data_transport import DataContainer, TextPacket
from sinapsis_protocol import deserialize_data_container, serialize_data_container

container = DataContainer(texts=[TextPacket(content="Hello from Sinapsis")])

packet: bytes = serialize_data_container(container)
restored = deserialize_data_container(packet)

assert isinstance(restored, DataContainer)
assert restored.texts[0].content == "Hello from Sinapsis"

serialize and deserialize are equivalent general entry points for supported values. The *_data_container names make the intended UDT boundary explicit.

Multimodal content and recursive traversal

With the NumPy adapter installed:

import numpy as np
from sinapsis.data_transport import DataContainer, ImagePacket, TextPacket
from sinapsis_protocol import deserialize_data_container, serialize_data_container

container = DataContainer(
    images=[
        ImagePacket(content=np.arange(300, dtype=np.float32).reshape(3, 10, 10))
    ],
    texts=[TextPacket(content="example")],
)

packet = serialize_data_container(container)
restored = deserialize_data_container(packet)

assert isinstance(restored.images[0].content, np.ndarray)
assert restored.images[0].content.shape == (3, 10, 10)

The serializer traverses the logical tree recursively:

DataContainer
├── images
│   └── ImagePacket
│       ├── content ── NumPy adapter → binary payload
│       ├── id
│       ├── source
│       └── other packet fields
└── texts
    └── TextPacket
        └── content ── string

The registered adapter applies to the leaf value. All other dataclass fields are encoded as part of the same recursive structure, including packet identifiers, metadata, and provenance fields when present.

Empty-container sentinel

An empty DataContainer is an intentional fast path:

from sinapsis.data_transport import DataContainer
from sinapsis_protocol import (
    ProtocolSentinel,
    deserialize_data_container,
    serialize_data_container,
)

packet = serialize_data_container(DataContainer())
assert deserialize_data_container(packet) is ProtocolSentinel.EMPTY_CONTAINER

This is a protocol control value, not an ordinary reconstructed DataContainer. Callers should handle it explicitly when decoding streams.

Wire format

A normal encoded container is a versioned MessagePack envelope. Its conceptual structure is:

{
    "protocol": "sinapsis-data",
    "major": 1,
    "minor": 0,
    "kind": "container",
    "payload": ...,
}

The fields separate protocol identity, compatibility version, message kind, and the encoded data tree. The top-level structure is consistent even when its leaf values use different codecs.

Structured dataclass representation

A registered dataclass is represented conceptually as:

{
    "__type__": "dataclass",
    "version": 1,
    "name": "myapp:my-custom-packet",
    "fields": {
        "field_a": ...,
        "field_b": ...,
    },
}

The name and version select a type from the receiver's explicit dataclass registry. The Python module path need not be part of the wire contract.

Typed payload and transport models

Internally, the protocol uses typed dataclasses to describe payloads and their representations. A simplified view of the actual model structure is:

TransportValue
├── descriptor: PayloadDescriptor
│   ├── kind
│   ├── version
│   ├── library
│   └── codec
├── metadata: Metadata
│   └── type-specific fields (shape, dtype, device, ...)
└── payload: Payload
    ├── kind: INLINE | ARTIFACT
    ├── inline: InlinePayload | None
    ├── artifact: ArtifactPayload | None
    └── extras

ArrayMetadata, TorchMetadata, ImageMetadata, DataFrameMetadata, and other specialised metadata classes capture representation-specific details. The typed models are converted to ordinary MessagePack-compatible mappings at the final wire boundary.

An encoded NumPy value looks conceptually like:

{
    "__type__": "array",
    "version": 1,
    "library": "numpy",
    "codec": "raw",
    "metadata": {
        "shape": [3, 10, 10],
        "dtype": "<f4",
        "order": "C",
    },
    "payload": {
        "kind": "inline",
        "inline": {"data": b"...", "sha256": "..."},
    },
}

Payload metadata is necessary for decoding: an array's byte sequence is insufficient without shape and dtype information. Protocol models also carry format and version metadata to distinguish specialised representations.

Sentinels: fast control signals without a data payload

Not every exchange carries application data. A runtime may need to signal no content, a heartbeat, or the end of a stream many times per second. Wrapping each of those events in a full DataContainer and a normal wire envelope would waste bytes, allocations, and encoding/decoding work.

For that reason, the protocol reserves MessagePack extension code 42 for compact control values. Each sentinel is encoded as a three-byte fixext 1 value:

0xD4       0x2A       0x01 ... 0x05
fixext1    code 42    sentinel value

The decoder can distinguish the control message from a normal container without walking a dataclass graph, decoding payload metadata, or reconstructing packets. This is especially valuable for frequent empty results, stream heartbeats, and completion signalling, where control-message overhead can otherwise dominate useful work.

Sentinel Purpose
EMPTY_CONTAINER An empty DataContainer has no content to serialize; the serializer emits the compact control value instead.
EMPTY_PACKET Reserved for a packet-level empty-value signal.
NULL_VALUE Reserved to distinguish an explicit protocol-level null signal.
HEARTBEAT A lightweight liveness/progress signal without an application payload.
END_OF_STREAM A distinct end-of-stream control marker.

The non-empty sentinel values are available to protocol consumers; their use depends on the surrounding transport and application. The protocol does not imply that every stream automatically emits heartbeats or an end marker.

from sinapsis_protocol import (
    ProtocolSentinel,
    decode_sentinel,
    encode_sentinel,
    is_sentinel_packet,
)

heartbeat: bytes = encode_sentinel(ProtocolSentinel.HEARTBEAT)
assert len(heartbeat) == 3
assert is_sentinel_packet(heartbeat)
assert ProtocolSentinel(decode_sentinel(heartbeat)) is ProtocolSentinel.HEARTBEAT

is_sentinel_packet is a cheap check for the sentinel wire shape; use the decoder to validate the extension payload and its known value. A normal container still uses the versioned MessagePack envelope and the usual registered decoding path.

Control plane versus data plane: sentinels communicate protocol state; DataContainer and packet values communicate application data. Treating them separately avoids paying the full data-serialization cost for messages that have no payload.

Wire envelopes and streaming events

The wire format describes how data is encoded. A wire envelope describes the context of the exchange carrying that data. The two concerns are distinct.

The package provides SSEEnvelope for API/SSE-style exchanges:

SSEEnvelope
├── agent_id
├── agent_status
├── event_type
├── request_type
├── job_id
├── errors
└── data → DataContainer | None

data is optional. When present, it represents content available in that event, not necessarily the complete result. For example, a streaming audio workflow may emit an envelope containing just the current audio chunk.

from sinapsis.data_transport import DataContainer, TextPacket
from sinapsis_protocol import (
    AgentStatus,
    EventType,
    RequestType,
    SSEEnvelope,
    deserialize_sse_envelope,
    serialize_sse_envelope,
)

envelope = SSEEnvelope(
    agent_id="agent-1",
    agent_status=AgentStatus.RUNNING,
    event_type=EventType.DATA,
    request_type=RequestType.STREAM,
    job_id="job-123",
    data=DataContainer(texts=[TextPacket(content="partial output")]),
)

packet = serialize_sse_envelope(envelope)
restored = deserialize_sse_envelope(packet)
assert restored.job_id == "job-123"

The envelope is handled at the exchange boundary. Agents and Templates continue to consume DataContainer; they need not know whether an input arrived over an API, an event stream, or a local invocation.

For WebSocket transports that prefix an opaque encoded envelope with a MessagePack metadata map, split_websocket_frame separates the metadata and returns a view of the remaining envelope bytes. It does not itself decode the complete SSEEnvelope.

Wire envelope = exchange context. Wire format = encoded data representation.

Artifacts and payload placement

Large binary payloads need not be embedded in a single MessagePack allocation. The protocol separates the message representation from payload storage.

The encoder decides between an inline representation and an external artifact reference according to the payload and the configured thresholds:

Payload bytes
    ├── within inline limit → InlinePayload
    └── above inline limit  → ArtifactStore → ArtifactRef

The reference identifies the offloaded content; the receiving side must use a store capable of resolving it.

from sinapsis.data_transport import BinaryPacket, DataContainer
from sinapsis_protocol import (
    LocalArtifactStore,
    SerializationConfig,
    deserialize_data_container,
    serialize_data_container,
)
from sinapsis_protocol.types import SerializationLimits

store = LocalArtifactStore("./staging", username="example", agent_id="agent-1")
config = SerializationConfig(limits=SerializationLimits(max_inline_bytes=1024))

container = DataContainer(binary_data=[BinaryPacket(content=b"x" * 4096)])
packet = serialize_data_container(container, artifact_store=store, config=config)
restored = deserialize_data_container(packet, artifact_store=store, config=config)

The ArtifactStore interface permits other storage implementations without changing the wire contract. LocalArtifactStore stores content by digest and checks size and SHA-256 when retrieving it. A wire message containing an ArtifactRef is not self-contained; both endpoints must agree on how to retrieve that artifact.

A pathlib.Path is treated as a file payload. Plain strings are not automatically interpreted as paths unless the corresponding SerializationConfig path options are enabled.

Payload codecs

Built-in adapter specifications cover:

Payload type Representation Optional extra
NumPy arrays Raw binary with dtype and shape metadata numpy
Torch tensors Binary payload with tensor metadata torch
Pandas DataFrames Apache Arrow IPC stream pandas
Polars DataFrames Apache Arrow IPC stream polars
OpenCV images Image-specific payload representation cv2
bytes, str, Path, UUIDs, dates, etc. Core representations None
Custom or Protobuf objects Registered application adapter Application-specific

Optional adapters are loaded lazily. A caller can register an explicit override when another representation is more appropriate for a recognised type.

Register a new packet/dataclass type

Use dataclass registration when an object should be recursively traversed, including its nested fields:

from sinapsis.data_transport import DataContainer, dataclass, field
from sinapsis_protocol import default_registry, serialize_data_container

@dataclass
class MyCustomPacket:
    content: bytes
    label: str = ""
    metadata: dict[str, str] = field(default_factory=dict)

registry = default_registry()
registry.register_dataclass(
    MyCustomPacket,
    type_name="myapp:my-custom-packet",
    version=1,
)

container = DataContainer(generic_data={
    "custom": MyCustomPacket(content=b"sample", label="example")
})
packet = serialize_data_container(container, registry=registry)

For decoding, use a registry containing the same wire-name/version registration:

from sinapsis_protocol import deserialize_data_container

restored = deserialize_data_container(packet, registry=registry)

Stable names matter

Prefer a stable wire identity such as myapp:my-custom-packet over a Python import path such as my_package.models.MyCustomPacket. Python modules can be reorganised without changing the transport identity.

Versioning a custom packet

When an incompatible schema change is needed, give the new structure a new version:

registry.register_dataclass(
    MyCustomPacketV2,
    type_name="myapp:my-custom-packet",
    version=2,
)

Versions identify distinct registered schemas. Compatibility migrations between versions must be implemented intentionally; they are not inferred by the decoder.

Register a leaf/object adapter

Use a leaf adapter when the object should be handled as a single specialised payload rather than recursively walking its Python fields. The adapter decides how to encode and reconstruct the value.

The following example assumes an application-defined MyEmbedding type with to_bytes() and from_bytes() methods:

from sinapsis_protocol import default_registry
from sinapsis_protocol.codecs.base import make_payload, read_payload
from sinapsis_protocol.types import DecodeContext, EncodeContext
from sinapsis_protocol.wire.constants import PayloadCodec
from sinapsis_protocol.wire.models import (
    Metadata,
    PayloadDescriptor,
    TransportValue,
)

class MyEmbeddingAdapter:
    type_name = "embedding"
    library = "myapp"
    version = 1

    @classmethod
    def can_encode(cls, value: object) -> bool:
        return isinstance(value, MyEmbedding)

    @classmethod
    def encode(cls, value: object, context: EncodeContext) -> TransportValue:
        return TransportValue(
            descriptor=PayloadDescriptor(
                kind=cls.type_name,
                version=cls.version,
                library=cls.library,
                codec=PayloadCodec.RAW,
            ),
            metadata=Metadata(),
            payload=make_payload(
                value.to_bytes(),
                context,
                filename="embedding.bin",
                mime_type="application/octet-stream",
            ),
        )

    @classmethod
    def decode(cls, value: TransportValue, context: DecodeContext) -> object:
        return MyEmbedding.from_bytes(read_payload(value.payload, context))

registry = default_registry()
registry.register(MyEmbeddingAdapter)

Pass this registry to serialize_data_container and deserialize_data_container. An explicit adapter can override the corresponding built-in lazy adapter when its (type_name, library, version) matches.

The distinction is fundamental:

  • Dataclass registration: the protocol serializes the object's fields recursively.
  • Leaf adapter: the application owns the representation of that object as a transport value.

Protobuf as a payload codec

Protobuf is useful for a compact, language-neutral representation of a particular payload. Within UDT it belongs inside a packet, for example through a registered adapter:

DataContainer
└── MyProtoPacket
    └── protobuf message
         ↓
    protobuf serialization
         ↓
    payload bytes
         ↓
    MessagePack DataContainer wire representation

Likewise, NumPy may use raw binary, DataFrames use Arrow IPC, and other objects use their declared payload formats. None of these require replacing the universal container boundary.

Specialize the payload, not the universal container boundary.

Registry and extension model

AdapterRegistry
├── DataclassRegistry
│   └── explicitly registered structured packet types
└── Leaf adapters
    ├── NumPy
    ├── Torch
    ├── Pandas
    ├── Polars
    ├── OpenCV
    └── application overrides / custom codecs

The registry resolves known dataclasses by wire name and version and payload adapters by kind, library, and version. The default registry registers Sinapsis's public data-transport dataclasses and lazy built-in adapters. Applications can extend it explicitly.

If a value is not a supported primitive, registered dataclass, or recognised adapter type, encoding raises UnsupportedTypeError rather than silently pickling the object.

Resource limits and safety

SerializationConfig provides inline-handling controls and a SerializationLimits object. Supported limits include:

  • maximum encoded packet bytes (max_packet_bytes);
  • maximum inline bytes (max_inline_bytes);
  • maximum array bytes (max_array_bytes);
  • maximum collection size (max_collection_length);
  • maximum string bytes (max_string_bytes);
  • maximum nesting depth (max_nesting_depth).
from sinapsis_protocol import SerializationConfig
from sinapsis_protocol.types import SerializationLimits

config = SerializationConfig(
    inline_binary_limit=1024 * 1024,
    limits=SerializationLimits(max_nesting_depth=32),
)

For supported binary arrays, decoding validates expected byte length from shape and dtype before constructing the array. Inline payloads and local artifacts can carry integrity checksums.

The format has no implicit pickle/cloudpickle fallback and does not dynamically import arbitrary Python classes based on packet contents. Nonetheless, applications should register only trusted types/adapters, select limits appropriate to their workloads, and restrict artifact-store access as appropriate. Registry allow-listing and resource limits are complementary safeguards, not a substitute for application-level authorization.

Versioning policy

The current wire protocol identity is:

protocol = sinapsis-data
major    = 1
minor    = 0
  • Major is the compatibility boundary; receivers reject unsupported major versions.
  • Minor allows compatible protocol additions and optional fields.
  • Registered dataclasses and leaf adapters have their own independent versions.

The generic protocol promises reconstruction of supported typed data, not preservation of Python object identity, shared references, running state, or arbitrary implementation details.

The wire protocol version is separate from the Python distribution version.

Supported scope and boundaries

Included: recursive container/dataclass representation, MessagePack framing, typed payload metadata, NumPy/Torch/Pandas/Polars/OpenCV adapters, inline and artifact-backed payloads, explicit custom types, configurable resource limits, streaming envelopes, and protocol sentinels.

Not a goal: arbitrary object graphs, live processes, automatic transport of torch.nn.Module objects, implicit pickle execution, or a separate top-level protocol for every data type. An application-specific Protobuf contract remains possible, but it is not the generic UDT contract.

sinapsis-serializer-core and sinapsis-deserialization use an older, separate representation for existing Cloud API integrations; protocol bytes should be decoded using the matching sinapsis-protocol decoder.

Source layout

src/sinapsis_protocol/
├── container/       # DataContainer integration and serialization config
├── wire/            # MessagePack, typed wire models, envelopes, sentinels, frames
├── dataclass/       # Recursive dataclass encoding and registration
├── codecs/          # Built-in optional adapters and codec registry
├── artifacts/       # ArtifactStore, ArtifactRef, local staging
├── types.py         # Limits and adapter/context contracts
└── errors.py        # Protocol-specific errors

Development

pip install -e '.[dev]'
pytest

The test suite covers wire encoding, dataclass registries, supported payload adapters, artifacts, sentinel handling, and SSE envelopes. Integration tests using the supported Sinapsis data-transport models are particularly important for compatibility.

Documentation

License

Sinapsis open-source components are available under your choice of the MIT License or the Apache License 2.0, unless otherwise noted.

Metadata

Release files for sinapsis_protocol 1.0.0

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for sinapsis_protocol 1.0.0
File Size Uploaded Provenance Actions
sinapsis_protocol-1.0.0.tar.gz 149.9 kB Without provenance Details for sinapsis_protocol-1.0.0.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for sinapsis_protocol 1.0.0
File Interpreter ABI Platform Actions
sinapsis_protocol-1.0.0-py3-none-any.whl Python 3 none any Details for sinapsis_protocol-1.0.0-py3-none-any.whl

Total release size: 192.5 kB

Release files / sinapsis_protocol-1.0.0.tar.gz

Download URL sinapsis_protocol-1.0.0.tar.gz
Size 149.9 kB
Tags Source
SHA-256 checksum
How to use checksums
a1a410feed04f4ab719c28a022fd3a5c874590118f59ad4a02a4b42c4850dd32
BLAKE2b-256 checksum
How to use checksums
6b3b660c89eea9bdc5421e3ab2cf692b3f7159b736cac94de997574da93d1590
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via uv/0.12.10 {"installer":{"name":"uv","version":"0.12.10","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"22.04","id":"jammy","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":null}

Release files / sinapsis_protocol-1.0.0-py3-none-any.whl

Download URL sinapsis_protocol-1.0.0-py3-none-any.whl
Size 42.6 kB
Tags Python 3
SHA-256 checksum
How to use checksums
d73dc7c163d0061bd7dce15e17bc0f19249e0da72616dd4fb602e5dc1236c423
BLAKE2b-256 checksum
How to use checksums
bee0aefa07490c9bdcc14caf9864285e18ae6969c1d2be874a479b1753677aad
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via uv/0.12.10 {"installer":{"name":"uv","version":"0.12.10","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"22.04","id":"jammy","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":null}

Security for sinapsis_protocol 1.0.0

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Release history Release notifications | RSS feed

This release

1.0.0 This release

2 release files No provenance

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page