metaspn-schemas 0.1.0__py3-none-any.whl

metaspn_schemas/__init__.py

@@ -0,0 +1,46 @@
+from metaspn_schemas.core import (
+    EmissionEnvelope,
+    EntityRef,
+    SchemaVersion,
+    SignalEnvelope,
+    TraceContext,
+)
+from metaspn_schemas.entities import EntityAliasAdded, EntityMerged, EntityResolved
+from metaspn_schemas.features import (
+    GameClassified,
+    PlaybookRouted,
+    ProfileEnriched,
+    ScoresComputed,
+)
+from metaspn_schemas.outcomes import MeetingBooked, MessageSent, ReplyReceived, RevenueEvent
+from metaspn_schemas.social import ProfileSnapshotSeen, SocialPostSeen
+from metaspn_schemas.state_fragments import Attempts, Cooldowns, Evidence, Identity, Scores
+from metaspn_schemas.tasks import Result, Task
+
+__all__ = [
+    "Attempts",
+    "Cooldowns",
+    "EmissionEnvelope",
+    "EntityAliasAdded",
+    "EntityMerged",
+    "EntityRef",
+    "EntityResolved",
+    "Evidence",
+    "GameClassified",
+    "Identity",
+    "MeetingBooked",
+    "MessageSent",
+    "PlaybookRouted",
+    "ProfileEnriched",
+    "ProfileSnapshotSeen",
+    "ReplyReceived",
+    "Result",
+    "RevenueEvent",
+    "SchemaVersion",
+    "Scores",
+    "ScoresComputed",
+    "SignalEnvelope",
+    "SocialPostSeen",
+    "Task",
+    "TraceContext",
+]

metaspn_schemas/core.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+from metaspn_schemas.utils.serde import Serializable
+from metaspn_schemas.utils.time import ensure_utc
+
+DEFAULT_SCHEMA_VERSION = "0.1"
+
+
+@dataclass(frozen=True)
+class SchemaVersion(Serializable):
+    package: str = "metaspn-schemas"
+    version: str = DEFAULT_SCHEMA_VERSION
+
+
+@dataclass(frozen=True)
+class EntityRef(Serializable):
+    ref_type: str
+    value: str
+    platform: str | None = None
+    label: str | None = None
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+
+
+@dataclass(frozen=True)
+class TraceContext(Serializable):
+    trace_id: str
+    caused_by: tuple[str, ...] = field(default_factory=tuple)
+    provenance: str | None = None
+    redactions: tuple[str, ...] = field(default_factory=tuple)
+    metadata: dict[str, str] = field(default_factory=dict)
+    privacy_mode: bool = False
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+
+
+@dataclass(frozen=True)
+class SignalEnvelope(Serializable):
+    signal_id: str
+    timestamp: datetime
+    source: str
+    payload_type: str
+    payload: Any
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+    entity_refs: tuple[EntityRef, ...] = field(default_factory=tuple)
+    trace: TraceContext | None = None
+    raw: dict[str, Any] | None = field(default=None, metadata={"omit_in_privacy_mode": True})
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "timestamp", ensure_utc(self.timestamp))
+
+
+@dataclass(frozen=True)
+class EmissionEnvelope(Serializable):
+    emission_id: str
+    timestamp: datetime
+    emission_type: str
+    payload: Any
+    caused_by: str
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+    trace: TraceContext | None = None
+    entity_refs: tuple[EntityRef, ...] = field(default_factory=tuple)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "timestamp", ensure_utc(self.timestamp))

metaspn_schemas/entities.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+
+from metaspn_schemas.core import DEFAULT_SCHEMA_VERSION
+from metaspn_schemas.utils.serde import Serializable
+
+
+@dataclass(frozen=True)
+class EntityResolved(Serializable):
+    entity_id: str
+    resolver: str
+    resolved_at: datetime
+    confidence: float
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+
+
+@dataclass(frozen=True)
+class EntityMerged(Serializable):
+    entity_id: str
+    merged_from: tuple[str, ...]
+    merged_at: datetime
+    reason: str | None = None
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+
+
+@dataclass(frozen=True)
+class EntityAliasAdded(Serializable):
+    entity_id: str
+    alias: str
+    alias_type: str
+    added_at: datetime
+    schema_version: str = DEFAULT_SCHEMA_VERSION

metaspn_schemas/features.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+
+from metaspn_schemas.core import DEFAULT_SCHEMA_VERSION
+from metaspn_schemas.utils.serde import Serializable
+
+
+@dataclass(frozen=True)
+class ProfileEnriched(Serializable):
+    entity_id: str
+    enriched_at: datetime
+    summary: str
+    topics: tuple[str, ...] = field(default_factory=tuple)
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "topics", tuple(sorted(self.topics)))
+
+
+@dataclass(frozen=True)
+class ScoresComputed(Serializable):
+    entity_id: str
+    computed_at: datetime
+    scores: dict[str, float]
+    scorer: str
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+
+
+@dataclass(frozen=True)
+class PlaybookRouted(Serializable):
+    task_id: str
+    routed_at: datetime
+    playbook: str
+    rationale: str | None = None
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+
+
+@dataclass(frozen=True)
+class GameClassified(Serializable):
+    entity_id: str
+    classified_at: datetime
+    label: str
+    confidence: float
+    schema_version: str = DEFAULT_SCHEMA_VERSION

metaspn_schemas/outcomes.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+
+from metaspn_schemas.core import DEFAULT_SCHEMA_VERSION
+from metaspn_schemas.utils.serde import Serializable
+
+
+@dataclass(frozen=True)
+class MessageSent(Serializable):
+    message_id: str
+    channel: str
+    recipient: str
+    sent_at: datetime
+    subject: str | None = None
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+
+
+@dataclass(frozen=True)
+class ReplyReceived(Serializable):
+    reply_id: str
+    message_id: str
+    sender: str
+    received_at: datetime
+    sentiment: str | None = None
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+
+
+@dataclass(frozen=True)
+class MeetingBooked(Serializable):
+    meeting_id: str
+    organizer: str
+    booked_at: datetime
+    starts_at: datetime
+    attendees: tuple[str, ...]
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+
+
+@dataclass(frozen=True)
+class RevenueEvent(Serializable):
+    revenue_id: str
+    amount: float
+    currency: str
+    recognized_at: datetime
+    source: str
+    schema_version: str = DEFAULT_SCHEMA_VERSION

metaspn_schemas/social.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+
+from metaspn_schemas.core import DEFAULT_SCHEMA_VERSION
+from metaspn_schemas.utils.serde import Serializable
+
+
+@dataclass(frozen=True)
+class SocialPostSeen(Serializable):
+    post_id: str
+    platform: str
+    author_handle: str
+    content: str
+    seen_at: datetime
+    url: str | None = None
+    topics: tuple[str, ...] = field(default_factory=tuple)
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "topics", tuple(sorted(self.topics)))
+
+
+@dataclass(frozen=True)
+class ProfileSnapshotSeen(Serializable):
+    profile_id: str
+    platform: str
+    handle: str
+    display_name: str | None
+    bio: str | None
+    seen_at: datetime
+    followers_count: int | None = None
+    topics: tuple[str, ...] = field(default_factory=tuple)
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "topics", tuple(sorted(self.topics)))

metaspn_schemas/state_fragments.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+
+from metaspn_schemas.core import DEFAULT_SCHEMA_VERSION
+from metaspn_schemas.utils.serde import Serializable
+
+
+@dataclass(frozen=True)
+class Identity(Serializable):
+    entity_id: str
+    canonical_name: str | None = None
+    aliases: tuple[str, ...] = field(default_factory=tuple)
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+
+
+@dataclass(frozen=True)
+class Evidence(Serializable):
+    evidence_id: str
+    entity_id: str
+    source: str
+    collected_at: datetime
+    attributes: dict[str, str] = field(default_factory=dict)
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+
+
+@dataclass(frozen=True)
+class Scores(Serializable):
+    entity_id: str
+    values: dict[str, float]
+    updated_at: datetime
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+
+
+@dataclass(frozen=True)
+class Cooldowns(Serializable):
+    entity_id: str
+    channel: str
+    until: datetime
+    reason: str | None = None
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+
+
+@dataclass(frozen=True)
+class Attempts(Serializable):
+    entity_id: str
+    count: int
+    last_attempt_at: datetime | None = None
+    schema_version: str = DEFAULT_SCHEMA_VERSION

metaspn_schemas/tasks.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+from metaspn_schemas.core import DEFAULT_SCHEMA_VERSION, EntityRef
+from metaspn_schemas.utils.serde import Serializable
+
+
+@dataclass(frozen=True)
+class Task(Serializable):
+    task_id: str
+    task_type: str
+    created_at: datetime
+    priority: int
+    entity_ref: EntityRef
+    inputs: dict[str, Any] = field(default_factory=dict)
+    context: dict[str, Any] = field(default_factory=dict)
+    schema_version: str = DEFAULT_SCHEMA_VERSION
+
+
+@dataclass(frozen=True)
+class Result(Serializable):
+    result_id: str
+    task_id: str
+    status: str
+    completed_at: datetime
+    outputs: dict[str, Any] = field(default_factory=dict)
+    errors: tuple[str, ...] = field(default_factory=tuple)
+    schema_version: str = DEFAULT_SCHEMA_VERSION

metaspn_schemas/utils/__init__.py

@@ -0,0 +1,14 @@
+from metaspn_schemas.utils.ids import generate_id
+from metaspn_schemas.utils.serde import Serializable, dataclass_from_dict, dataclass_to_dict
+from metaspn_schemas.utils.time import datetime_to_str, ensure_utc, str_to_datetime, utc_now
+
+__all__ = [
+    "Serializable",
+    "dataclass_from_dict",
+    "dataclass_to_dict",
+    "datetime_to_str",
+    "ensure_utc",
+    "generate_id",
+    "str_to_datetime",
+    "utc_now",
+]

metaspn_schemas/utils/ids.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import uuid
+
+
+VALID_PREFIXES = {
+    "signal": "s",
+    "emission": "e",
+    "task": "t",
+    "result": "r",
+    "entity": "ent",
+}
+
+
+def generate_id(prefix: str | None = None) -> str:
+    token = uuid.uuid4().hex
+    if prefix is None:
+        return token
+    normalized = prefix.strip().lower()
+    mapped = VALID_PREFIXES.get(normalized, normalized)
+    return f"{mapped}_{token}"

metaspn_schemas/utils/serde.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import types
+from dataclasses import MISSING, fields, is_dataclass
+from datetime import datetime
+from typing import Any, TypeVar, Union, get_args, get_origin, get_type_hints
+
+from metaspn_schemas.utils.time import datetime_to_str, str_to_datetime
+
+T = TypeVar("T")
+
+
+class Serializable:
+    def to_dict(self, *, privacy_mode: bool = False) -> dict[str, Any]:
+        return dataclass_to_dict(self, privacy_mode=privacy_mode)
+
+    @classmethod
+    def from_dict(cls: type[T], data: dict[str, Any]) -> T:
+        return dataclass_from_dict(cls, data)
+
+
+def dataclass_to_dict(obj: Any, *, privacy_mode: bool = False) -> dict[str, Any]:
+    if not is_dataclass(obj):
+        raise TypeError("dataclass_to_dict expects a dataclass instance")
+
+    output: dict[str, Any] = {}
+    for f in fields(obj):
+        if privacy_mode and f.metadata.get("omit_in_privacy_mode"):
+            continue
+        value = getattr(obj, f.name)
+        output[f.name] = _to_primitive(value, privacy_mode=privacy_mode)
+    return output
+
+
+def _to_primitive(value: Any, *, privacy_mode: bool) -> Any:
+    if is_dataclass(value):
+        return dataclass_to_dict(value, privacy_mode=privacy_mode)
+    if isinstance(value, datetime):
+        return datetime_to_str(value)
+    if isinstance(value, tuple):
+        return [_to_primitive(v, privacy_mode=privacy_mode) for v in value]
+    if isinstance(value, list):
+        return [_to_primitive(v, privacy_mode=privacy_mode) for v in value]
+    if isinstance(value, dict):
+        return {k: _to_primitive(v, privacy_mode=privacy_mode) for k, v in sorted(value.items())}
+    return value
+
+
+def dataclass_from_dict(cls: type[T], data: dict[str, Any]) -> T:
+    if not is_dataclass(cls):
+        raise TypeError("dataclass_from_dict expects a dataclass type")
+
+    hints = get_type_hints(cls)
+    kwargs: dict[str, Any] = {}
+
+    for f in fields(cls):
+        hint = hints.get(f.name, Any)
+        if f.name in data:
+            kwargs[f.name] = _coerce_value(hint, data[f.name])
+            continue
+
+        if f.default is not MISSING:
+            kwargs[f.name] = f.default
+            continue
+
+        if f.default_factory is not MISSING:  # type: ignore[attr-defined]
+            kwargs[f.name] = f.default_factory()  # type: ignore[misc]
+            continue
+
+        raise ValueError(f"Missing required field: {f.name}")
+
+    return cls(**kwargs)
+
+
+def _coerce_value(hint: Any, value: Any) -> Any:
+    if value is None:
+        return None
+
+    origin = get_origin(hint)
+    args = get_args(hint)
+
+    if hint is Any:
+        return value
+
+    if hint is datetime:
+        if isinstance(value, datetime):
+            return value
+        if isinstance(value, str):
+            return str_to_datetime(value)
+        raise TypeError(f"Cannot parse datetime from {type(value)!r}")
+
+    if origin in (Union, types.UnionType):
+        last_error: Exception | None = None
+        for option in args:
+            if option is type(None):
+                continue
+            try:
+                return _coerce_value(option, value)
+            except Exception as err:  # noqa: BLE001
+                last_error = err
+        if last_error is not None:
+            raise last_error
+        return value
+
+    if origin is tuple:
+        item_type = args[0] if args else Any
+        return tuple(_coerce_value(item_type, item) for item in value)
+
+    if origin is list:
+        item_type = args[0] if args else Any
+        return [_coerce_value(item_type, item) for item in value]
+
+    if origin is dict:
+        key_type = args[0] if len(args) > 0 else Any
+        value_type = args[1] if len(args) > 1 else Any
+        return {
+            _coerce_value(key_type, k): _coerce_value(value_type, v)
+            for k, v in value.items()
+        }
+
+    if is_dataclass(hint):
+        if isinstance(value, hint):
+            return value
+        if isinstance(value, dict):
+            return dataclass_from_dict(hint, value)
+
+    if hint in (str, int, float, bool):
+        return hint(value)
+
+    return value

metaspn_schemas/utils/time.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+
+def utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def ensure_utc(value: datetime) -> datetime:
+    if value.tzinfo is None:
+        return value.replace(tzinfo=timezone.utc)
+    return value.astimezone(timezone.utc)
+
+
+def datetime_to_str(value: datetime) -> str:
+    utc_value = ensure_utc(value)
+    return utc_value.isoformat().replace("+00:00", "Z")
+
+
+def str_to_datetime(value: str) -> datetime:
+    text = value[:-1] + "+00:00" if value.endswith("Z") else value
+    parsed = datetime.fromisoformat(text)
+    return ensure_utc(parsed)

metaspn_schemas-0.1.0.dist-info/METADATA

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: metaspn-schemas
+Version: 0.1.0
+Summary: Canonical schemas for MetaSPN-compatible signal processing systems
+Author: MetaSPN
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/MetaSPN/metaspn-schemas
+Project-URL: Repository, https://github.com/MetaSPN/metaspn-schemas
+Project-URL: Issues, https://github.com/MetaSPN/metaspn-schemas/issues
+Keywords: schemas,signal-processing,events,dataclasses,metaspn
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: build>=1.2.0; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+Dynamic: license-file
+
+# metaspn-schemas
+
+Canonical, stdlib-only schema package for MetaSPN-compatible systems.
+
+## Install
+
+```bash
+pip install metaspn-schemas
+```
+
+## Development
+
+```bash
+python -m pip install -e .[dev]
+pytest -q
+python -m build
+python -m twine check dist/*
+```
+
+## Design constraints
+
+- Tiny and dependency-light (stdlib only)
+- Frozen dataclasses for immutable-by-default objects
+- Explicit `schema_version` on all public objects
+- `to_dict()` / `from_dict()` on every schema
+- UTC ISO-8601 datetime serialization
+- Traceability metadata (`trace_id`, `caused_by`, provenance)
+- Privacy mode support (`to_dict(privacy_mode=True)` omits raw blobs)
+
+## Example
+
+```python
+from datetime import timezone, datetime
+
+from metaspn_schemas import SignalEnvelope
+from metaspn_schemas.utils.ids import generate_id
+
+signal = SignalEnvelope(
+    signal_id=generate_id("signal"),
+    timestamp=datetime.now(timezone.utc),
+    source="linkedin.webhook",
+    payload_type="SocialPostSeen",
+    payload={"post_id": "123", "platform": "linkedin"},
+    schema_version="0.1",
+)
+
+as_dict = signal.to_dict()
+round_trip = SignalEnvelope.from_dict(as_dict)
+```
+
+## Public imports
+
+```python
+from metaspn_schemas import (
+    SignalEnvelope,
+    EmissionEnvelope,
+    Task,
+    Result,
+    SocialPostSeen,
+    ProfileEnriched,
+    ScoresComputed,
+)
+```
+
+## Package layout
+
+```text
+metaspn-schemas/
+  pyproject.toml
+  README.md
+  src/metaspn_schemas/
+    __init__.py
+    core.py
+    tasks.py
+    entities.py
+    social.py
+    outcomes.py
+    features.py
+    state_fragments.py
+    utils/
+      ids.py
+      time.py
+      serde.py
+  test/
+    test_serde.py
+    test_ids.py
+    test_backcompat.py
+```
+
+## Release
+
+Release automation is configured in:
+
+- `.github/workflows/ci.yml`
+- `.github/workflows/publish.yml`
+
+See `RELEASE.md` for the end-to-end push + PyPI release flow.

metaspn_schemas-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+metaspn_schemas/__init__.py,sha256=zAryvrNvDBXXWOokiizwpQmpr3Orxp5VcvWMmCIJX08,1149
+metaspn_schemas/core.py,sha256=ERkkWxnMVZ0P6_g3qruEOwxU2i59UvlDZUBKiSEnZoc,1942
+metaspn_schemas/entities.py,sha256=jl_3Ie8vyaF1En2mcDHPGU0Sszz-oQu4OmYtWBak0Vg,811
+metaspn_schemas/features.py,sha256=Z9Nh-o_At1e3UETelHidGm44R3P2T7WuybQikUi6F5A,1158
+metaspn_schemas/outcomes.py,sha256=-t7S-Rn75INcIMMrxZNFnyYcDg804AP2aOQEEJm2P3U,1087
+metaspn_schemas/social.py,sha256=r-2t0z35bRNUo0MqNMTuh2Tt7DuouKFo0XGnn0grFxY,1068
+metaspn_schemas/state_fragments.py,sha256=YzHmyAdcpWQL-ALwDQezVSFEu4mQAmbqc6cNtqZaBg8,1239
+metaspn_schemas/tasks.py,sha256=ZXHJl6kWq6l1B47hRxN80QXdVSgWDcTuDC-mJitnsbY,871
+metaspn_schemas/utils/__init__.py,sha256=Vz4fl0V2Gwpjq3tGsFSLNSbihZUyUMN_f6UIHRuKKiY,421
+metaspn_schemas/utils/ids.py,sha256=avUMruGrC0rKxPspmJgFk9eGa2BvUsFAYA-NkSyuKK4,421
+metaspn_schemas/utils/serde.py,sha256=f-lhqGCXEtOeAP_Ea5nJT5Dsho-EhQghMnJA7hVWGhY,4065
+metaspn_schemas/utils/time.py,sha256=U5l8_ZXIKgAIzvGB8wOkCewzhjKI5ygfCCzTLFu-_3A,634
+metaspn_schemas-0.1.0.dist-info/licenses/LICENSE,sha256=a9HFx7YHIoXQV8KLxqBH1uEJ6Ok6-yGkFu0_4fi2Zu0,1064
+metaspn_schemas-0.1.0.dist-info/METADATA,sha256=yHv_y7EVqAgi4WctNkP-KPo_3wTkwLwOCkpVdvE-wwE,2700
+metaspn_schemas-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+metaspn_schemas-0.1.0.dist-info/top_level.txt,sha256=Vqx4EYfSXtLghSiLIlorpPnFPNJg7YBgGvO1ZQyW6WM,16
+metaspn_schemas-0.1.0.dist-info/RECORD,,

metaspn_schemas-0.1.0.dist-info/WHEEL

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

metaspn_schemas-0.1.0.dist-info/licenses/LICENSE

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

metaspn_schemas-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+metaspn_schemas