earshot-observability 0.1.0__py3-none-any.whl

earshot/__init__.py

@@ -0,0 +1,125 @@
+"""Earshot Python SDK contract surface."""
+
+from .codec import (  # noqa: F401 - legacy direct attributes; import from earshot.codec
+    JSON_MEDIA_TYPE,
+    PROTOBUF_MEDIA_TYPE,
+    IncidentCodecError,
+    IncidentDepthError,
+    analysis_input_sha256,
+    canonical_profile_json,
+    decode_incident_json,
+    decode_incident_protobuf,
+    decode_json,
+    decode_protobuf,
+    encode_incident_json,
+    encode_incident_protobuf,
+    encode_json,
+    encode_protobuf,
+)
+from .context import (  # noqa: F401 - legacy direct attributes; import from earshot.context
+    ContextSnapshot,
+    current_context,
+    current_conversation,
+    current_operation,
+    is_instrumentation_suppressed,
+    suppress_instrumentation,
+)
+from .contract import (  # noqa: F401 - legacy direct attributes; import from earshot.contract
+    SCHEMA_VERSION,
+    SEMANTIC_PROFILE_VERSION,
+    Adapter,
+    AnalysisMetric,
+    AnalysisProjections,
+    AnalysisSummary,
+    AudioFormat,
+    AudioStream,
+    BundleManifest,
+    ByteRange,
+    CaptureClassPolicy,
+    CausalLink,
+    ClockDomain,
+    ConsentRecord,
+    Coverage,
+    DerivedAnalysis,
+    Diagnosis,
+    ErrorRecord,
+    Event,
+    Evidence,
+    ExportPolicy,
+    IncidentBundle,
+    IncidentBundleJson,
+    IncidentProfile,
+    InterruptionProjection,
+    JsonRawOtlpChunk,
+    MediaLocator,
+    MediaRef,
+    Omission,
+    Operation,
+    Participant,
+    PrivacyManifest,
+    Producer,
+    QualityMeasurement,
+    QualitySample,
+    RawOtlpChunk,
+    RedactionRecord,
+    RetentionPolicy,
+    Session,
+    TimePoint,
+    TimeRange,
+    ToolAnalysis,
+    TurnMetrics,
+    TurnProjection,
+)
+from .pipeline import PipelineSession, TurnRecorder, pipeline  # noqa: F401
+from .privacy import (  # noqa: F401 - legacy direct attributes; import from earshot.privacy
+    CaptureClass,
+    CaptureGovernance,
+    CapturePolicy,
+    ConsentConfig,
+    ExportConfig,
+    ExportPolicyError,
+    RedactionConfig,
+    RetentionConfig,
+    assert_export_allowed,
+)
+from .recorder import IncidentRecorder, RecorderConfig, RecorderStatus  # noqa: F401
+from .sdk import (  # noqa: F401 - configure remains a compatibility attribute
+    Client,
+    ClientStatus,
+    SamplingDecision,
+    SdkConfig,
+    configure,
+    conversation,
+    flush,
+    get_client,
+    init,
+    session,
+    shutdown,
+    status,
+)
+from .validation import (  # noqa: F401 - legacy; import from earshot.validation
+    IncidentValidationError,
+    ValidationIssue,
+    ValidationReport,
+    assert_valid_incident,
+    validate_derived_analysis,
+    validate_incident,
+)
+
+__all__ = [
+    "CaptureClass",
+    "CapturePolicy",
+    "Client",
+    "ClientStatus",
+    "SamplingDecision",
+    "SdkConfig",
+    "conversation",
+    "flush",
+    "get_client",
+    "init",
+    "pipeline",
+    "session",
+    "shutdown",
+    "status",
+    "suppress_instrumentation",
+]

earshot/adapters/__init__.py

@@ -0,0 +1,11 @@
+"""Optional framework adapters.
+
+Importing :mod:`earshot` never imports optional framework dependencies. Adapter
+modules use duck-typed source records so their mapping logic remains testable
+without installing a voice runtime.
+"""
+
+from .livekit import LiveKitAdapter
+from .pipecat import PipecatAdapter
+
+__all__ = ["LiveKitAdapter", "PipecatAdapter"]

earshot/adapters/base.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import hashlib
+from collections.abc import Mapping
+from typing import Any
+
+
+class AdapterDependencyError(RuntimeError):
+    pass
+
+
+def value(source: object, name: str, default: Any = None) -> Any:
+    if isinstance(source, Mapping):
+        return source.get(name, default)
+    return getattr(source, name, default)
+
+
+def stable_id(prefix: str, *parts: object) -> str:
+    digest = hashlib.sha256("\x1f".join(map(str, parts)).encode()).hexdigest()[:24]
+    return f"{prefix}-{digest}"
+
+
+def seconds_to_nano(value_in_seconds: object) -> int | None:
+    if isinstance(value_in_seconds, (int, float)) and value_in_seconds >= 0:
+        return round(float(value_in_seconds) * 1_000_000_000)
+    return None