labqoat 0.1.0__py3-none-any.whl

labqoat/__init__.py

@@ -0,0 +1,416 @@
+"""Typed Python SDK for the Labqoat private ML platform."""
+
+from labqoat.analytics import (
+    AnalyticsNamespace,
+    AnalyticsQuery,
+    AnalyticsResult,
+    AsyncAnalyticsNamespace,
+    LocalSnapshotMetadata,
+    QueryFilter,
+    QueryFilterOperator,
+    QueryMeasure,
+    QueryMeasureFunction,
+    QueryOrderDirection,
+    QueryOrdering,
+    QueryReceipt,
+    QueryScalar,
+    QueryValue,
+)
+from labqoat.async_client import AsyncLabqoatClient
+from labqoat.auth import (
+    AsyncSessionProvider,
+    ClientEnvironment,
+    PlatformSession,
+    SessionProvider,
+    StaticAsyncSessionProvider,
+    StaticSessionProvider,
+)
+from labqoat.checkpoint_contracts import (
+    Checkpoint,
+    CheckpointMember,
+    CheckpointRole,
+)
+from labqoat.client import LabqoatClient
+from labqoat.contract_artifacts import ContractArtifact
+from labqoat.contracts import (
+    Between,
+    ContractDefinition,
+    ContractKind,
+    Field,
+    Length,
+    NonEmpty,
+    Positive,
+    dataset_contract,
+    model_request_contract,
+    model_response_contract,
+)
+from labqoat.dataset_contracts import (
+    DatasetCard,
+    DatasetRepositoryRecord,
+    DatasetRepositorySpec,
+)
+from labqoat.datasets import (
+    DatasetInspection,
+    DatasetLineage,
+    DatasetRevisionSummary,
+    DatasetTag,
+    DatasetValidation,
+)
+from labqoat.errors import (
+    AuthenticationRequired,
+    CapacityUnavailable,
+    Conflict,
+    ContractIncompatible,
+    ErrorDetail,
+    InvalidRequest,
+    LabqoatError,
+    NetworkUnavailable,
+    NotFound,
+    OperationFailed,
+    RateLimited,
+    TransportFailure,
+)
+from labqoat.evaluations import (
+    AsyncEvaluationsNamespace,
+    Evaluation,
+    EvaluationContext,
+    EvaluationProgress,
+    EvaluationRunRef,
+    EvaluationsNamespace,
+    EvaluationState,
+    EvaluationSubmitter,
+    TrainingWithEvaluationsProgress,
+)
+from labqoat.events import (
+    CheckpointPublished,
+    EvaluationSubmitted,
+    RunEvent,
+    RunEventPage,
+    RunProgressed,
+    RunStateChanged,
+)
+from labqoat.identity import (
+    AuthChallenge,
+    AuthResult,
+    AwsIdentity,
+    DiagnosticCheck,
+    DiagnosticStatus,
+    Doctor,
+    HumanAuthenticator,
+    PlatformSessionExchange,
+    SignedAwsAssertion,
+)
+from labqoat.imports import (
+    AsyncImportsNamespace,
+    ExternalParquetAdapter,
+    FrozenManifestObject,
+    FrozenParquetObject,
+    FrozenSourceObject,
+    ImmutableManifestAdapter,
+    ImportContext,
+    ImportJob,
+    ImportRunRef,
+    ImportsNamespace,
+    ImportSourceError,
+    PublicationFinalizer,
+    SourceInspection,
+    SourceKind,
+)
+from labqoat.migration import DatasetResolution, DatasetStorageBackend
+from labqoat.model_contracts import (
+    ModelBuild,
+    ModelBuildSpec,
+    ModelDefinition,
+    ModelDefinitionSpec,
+    ModelInvocationResult,
+    ModelInvocationSpec,
+    ModelPromotion,
+    ModelRelease,
+    ModelReleaseSpec,
+    ModelReleaseView,
+    ReleaseState,
+)
+from labqoat.models import ModelBuildManifest, ModelReleaseManifest
+from labqoat.nodes import (
+    AsyncNodesNamespace,
+    CandidateEvaluation,
+    CapacityLimit,
+    CapacityPool,
+    ClusterNode,
+    NodeProvider,
+    NodesNamespace,
+    NodeState,
+    PlacementExplanation,
+)
+from labqoat.platform import (
+    PlatformDeployment,
+    PlatformPanel,
+    PlatformStatus,
+    resolve_panel_endpoint,
+)
+from labqoat.publication_contracts import (
+    DatasetPublication,
+    PublicationAttestation,
+    PublicationFile,
+    PublicationLineage,
+    PublicationReceipt,
+    PublicationShard,
+    PublicationSplit,
+    PublicationStatistics,
+)
+from labqoat.references import (
+    ArtifactRef,
+    AssetRef,
+    AudioRef,
+    CheckpointRef,
+    ContractRef,
+    DatasetRef,
+    ModelRef,
+    ResolvedDatasetRef,
+    ResourceId,
+    Sha256,
+)
+from labqoat.resources import CpuResources, GpuModel, GpuResources, Placement
+from labqoat.runs import (
+    ModelDependency,
+    Run,
+    RunDefinition,
+    RunExecution,
+    RunLog,
+    RunLogPage,
+    RunOutput,
+    RunShard,
+    RunState,
+    RunSubmission,
+    ShardState,
+    WorkloadKind,
+    canonical_parameter_sha256,
+)
+from labqoat.staging import ParquetStager, S3ParquetStager, S3PutClient
+from labqoat.training import (
+    AsyncTrainingNamespace,
+    TrainingContext,
+    TrainingJob,
+    TrainingNamespace,
+    TrainingRunRef,
+)
+from labqoat.transforms import (
+    AsyncTransformsNamespace,
+    BatchTransform,
+    FailurePolicy,
+    FlatMapTransform,
+    IdentifiedRow,
+    MapTransform,
+    TransformContext,
+    TransformJob,
+    TransformRunRef,
+    TransformsNamespace,
+    dataset_flat_map,
+    dataset_map,
+    dataset_map_batches,
+)
+from labqoat.workload_client import WorkerClient, WorkerEnvironment, WorkerInput
+from labqoat.workloads import (
+    HeartbeatReceipt,
+    LogSeverity,
+    WorkerAssignment,
+    WorkerContext,
+    WorkerControl,
+    WorkerLog,
+    WorkerProgress,
+    WorkerProtocolError,
+)
+
+__all__ = [
+    "AnalyticsNamespace",
+    "AnalyticsQuery",
+    "AnalyticsResult",
+    "ArtifactRef",
+    "AssetRef",
+    "AsyncAnalyticsNamespace",
+    "AsyncEvaluationsNamespace",
+    "AsyncImportsNamespace",
+    "AsyncLabqoatClient",
+    "AsyncNodesNamespace",
+    "AsyncSessionProvider",
+    "AsyncTrainingNamespace",
+    "AsyncTransformsNamespace",
+    "AudioRef",
+    "AuthChallenge",
+    "AuthResult",
+    "AuthenticationRequired",
+    "AwsIdentity",
+    "BatchTransform",
+    "Between",
+    "CandidateEvaluation",
+    "CapacityLimit",
+    "CapacityPool",
+    "CapacityUnavailable",
+    "Checkpoint",
+    "CheckpointMember",
+    "CheckpointPublished",
+    "CheckpointRef",
+    "CheckpointRole",
+    "ClientEnvironment",
+    "ClusterNode",
+    "Conflict",
+    "ContractArtifact",
+    "ContractDefinition",
+    "ContractIncompatible",
+    "ContractKind",
+    "ContractRef",
+    "CpuResources",
+    "DatasetCard",
+    "DatasetInspection",
+    "DatasetLineage",
+    "DatasetPublication",
+    "DatasetRef",
+    "DatasetRepositoryRecord",
+    "DatasetRepositorySpec",
+    "DatasetResolution",
+    "DatasetRevisionSummary",
+    "DatasetStorageBackend",
+    "DatasetTag",
+    "DatasetValidation",
+    "DiagnosticCheck",
+    "DiagnosticStatus",
+    "Doctor",
+    "ErrorDetail",
+    "Evaluation",
+    "EvaluationContext",
+    "EvaluationProgress",
+    "EvaluationRunRef",
+    "EvaluationState",
+    "EvaluationSubmitted",
+    "EvaluationSubmitter",
+    "EvaluationsNamespace",
+    "ExternalParquetAdapter",
+    "FailurePolicy",
+    "Field",
+    "FlatMapTransform",
+    "FrozenManifestObject",
+    "FrozenParquetObject",
+    "FrozenSourceObject",
+    "GpuModel",
+    "GpuResources",
+    "HeartbeatReceipt",
+    "HumanAuthenticator",
+    "IdentifiedRow",
+    "ImmutableManifestAdapter",
+    "ImportContext",
+    "ImportJob",
+    "ImportRunRef",
+    "ImportSourceError",
+    "ImportsNamespace",
+    "InvalidRequest",
+    "LabqoatClient",
+    "LabqoatError",
+    "Length",
+    "LocalSnapshotMetadata",
+    "LogSeverity",
+    "MapTransform",
+    "ModelBuild",
+    "ModelBuildManifest",
+    "ModelBuildSpec",
+    "ModelDefinition",
+    "ModelDefinitionSpec",
+    "ModelDependency",
+    "ModelInvocationResult",
+    "ModelInvocationSpec",
+    "ModelPromotion",
+    "ModelRef",
+    "ModelRelease",
+    "ModelReleaseManifest",
+    "ModelReleaseSpec",
+    "ModelReleaseView",
+    "NetworkUnavailable",
+    "NodeProvider",
+    "NodeState",
+    "NodesNamespace",
+    "NonEmpty",
+    "NotFound",
+    "OperationFailed",
+    "ParquetStager",
+    "Placement",
+    "PlacementExplanation",
+    "PlatformDeployment",
+    "PlatformPanel",
+    "PlatformSession",
+    "PlatformSessionExchange",
+    "PlatformStatus",
+    "Positive",
+    "PublicationAttestation",
+    "PublicationFile",
+    "PublicationFinalizer",
+    "PublicationLineage",
+    "PublicationReceipt",
+    "PublicationShard",
+    "PublicationSplit",
+    "PublicationStatistics",
+    "QueryFilter",
+    "QueryFilterOperator",
+    "QueryMeasure",
+    "QueryMeasureFunction",
+    "QueryOrderDirection",
+    "QueryOrdering",
+    "QueryReceipt",
+    "QueryScalar",
+    "QueryValue",
+    "RateLimited",
+    "ReleaseState",
+    "ResolvedDatasetRef",
+    "ResourceId",
+    "Run",
+    "RunDefinition",
+    "RunEvent",
+    "RunEventPage",
+    "RunExecution",
+    "RunLog",
+    "RunLogPage",
+    "RunOutput",
+    "RunProgressed",
+    "RunShard",
+    "RunState",
+    "RunStateChanged",
+    "RunSubmission",
+    "S3ParquetStager",
+    "S3PutClient",
+    "SessionProvider",
+    "Sha256",
+    "ShardState",
+    "SignedAwsAssertion",
+    "SourceInspection",
+    "SourceKind",
+    "StaticAsyncSessionProvider",
+    "StaticSessionProvider",
+    "TrainingContext",
+    "TrainingJob",
+    "TrainingNamespace",
+    "TrainingRunRef",
+    "TrainingWithEvaluationsProgress",
+    "TransformContext",
+    "TransformJob",
+    "TransformRunRef",
+    "TransformsNamespace",
+    "TransportFailure",
+    "WorkerAssignment",
+    "WorkerClient",
+    "WorkerContext",
+    "WorkerControl",
+    "WorkerEnvironment",
+    "WorkerInput",
+    "WorkerLog",
+    "WorkerProgress",
+    "WorkerProtocolError",
+    "WorkloadKind",
+    "canonical_parameter_sha256",
+    "dataset_contract",
+    "dataset_flat_map",
+    "dataset_map",
+    "dataset_map_batches",
+    "model_request_contract",
+    "model_response_contract",
+    "resolve_panel_endpoint",
+]
+
+__version__ = "0.1.0"

labqoat/analytics/__init__.py

@@ -0,0 +1,192 @@
+"""Snapshot-consistent analytics client namespaces and public contracts."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from labqoat.analytics_contracts import (
+    AnalyticsQuery,
+    AnalyticsResult,
+    LocalSnapshotMetadata,
+    QueryFilter,
+    QueryFilterOperator,
+    QueryMeasure,
+    QueryMeasureFunction,
+    QueryOrderDirection,
+    QueryOrdering,
+    QueryReceipt,
+    QueryScalar,
+    QueryValue,
+    analytics_query_document,
+    analytics_result_document,
+    analytics_sample_document,
+    parse_analytics_query,
+    parse_analytics_result,
+    parse_analytics_sample,
+)
+from labqoat.transport import HttpMethod, RequestTimeout, TransportRequest
+
+if TYPE_CHECKING:
+    from labqoat.auth import AsyncSessionProvider, SessionProvider
+    from labqoat.references import DatasetRef
+    from labqoat.retry import AsyncRequestExecutor, SyncRequestExecutor
+
+_QUERY_TIMEOUT = RequestTimeout(connect_seconds=5, total_seconds=120)
+
+
+class AnalyticsNamespace:
+    """Blocking snapshot-consistent analytics operations."""
+
+    __slots__ = ("_executor", "_sessions")
+
+    def __init__(
+        self,
+        executor: SyncRequestExecutor,
+        sessions: SessionProvider,
+    ) -> None:
+        self._executor = executor
+        self._sessions = sessions
+
+    def query[RowT](
+        self,
+        dataset: DatasetRef[RowT],
+        query: AnalyticsQuery,
+        *,
+        idempotency_key: str,
+    ) -> AnalyticsResult:
+        """Execute one bounded validated query against a resolved snapshot."""
+        response = self._executor.execute(
+            _query_request(
+                dataset,
+                query,
+                idempotency_key,
+                self._sessions.session().authorization_header(),
+            )
+        )
+        return parse_analytics_result(response.body)
+
+    def sample[RowT](
+        self,
+        dataset: DatasetRef[RowT],
+        *,
+        limit: int = 10,
+        idempotency_key: str,
+    ) -> AnalyticsResult:
+        """Return bounded complete records from one resolved snapshot."""
+        response = self._executor.execute(
+            _sample_request(
+                dataset,
+                limit,
+                idempotency_key,
+                self._sessions.session().authorization_header(),
+            )
+        )
+        return parse_analytics_result(response.body)
+
+
+class AsyncAnalyticsNamespace:
+    """Non-blocking snapshot-consistent analytics operations."""
+
+    __slots__ = ("_executor", "_sessions")
+
+    def __init__(
+        self,
+        executor: AsyncRequestExecutor,
+        sessions: AsyncSessionProvider,
+    ) -> None:
+        self._executor = executor
+        self._sessions = sessions
+
+    async def query[RowT](
+        self,
+        dataset: DatasetRef[RowT],
+        query: AnalyticsQuery,
+        *,
+        idempotency_key: str,
+    ) -> AnalyticsResult:
+        """Execute one bounded validated query without blocking."""
+        session = await self._sessions.session()
+        response = await self._executor.execute(
+            _query_request(
+                dataset,
+                query,
+                idempotency_key,
+                session.authorization_header(),
+            )
+        )
+        return parse_analytics_result(response.body)
+
+    async def sample[RowT](
+        self,
+        dataset: DatasetRef[RowT],
+        *,
+        limit: int = 10,
+        idempotency_key: str,
+    ) -> AnalyticsResult:
+        """Return bounded complete records from one resolved snapshot."""
+        session = await self._sessions.session()
+        response = await self._executor.execute(
+            _sample_request(
+                dataset,
+                limit,
+                idempotency_key,
+                session.authorization_header(),
+            )
+        )
+        return parse_analytics_result(response.body)
+
+
+def _query_request[RowT](
+    dataset: DatasetRef[RowT],
+    query: AnalyticsQuery,
+    idempotency_key: str,
+    authorization: tuple[str, str],
+) -> TransportRequest:
+    return TransportRequest(
+        method=HttpMethod.POST,
+        path="/v1/analytics/query",
+        timeout=_QUERY_TIMEOUT,
+        headers=(authorization,),
+        body=analytics_query_document(dataset, query),
+        idempotency_key=idempotency_key,
+    )
+
+
+def _sample_request[RowT](
+    dataset: DatasetRef[RowT],
+    limit: int,
+    idempotency_key: str,
+    authorization: tuple[str, str],
+) -> TransportRequest:
+    return TransportRequest(
+        method=HttpMethod.POST,
+        path="/v1/analytics/sample",
+        timeout=_QUERY_TIMEOUT,
+        headers=(authorization,),
+        body=analytics_sample_document(dataset, limit),
+        idempotency_key=idempotency_key,
+    )
+
+
+__all__ = [
+    "AnalyticsNamespace",
+    "AnalyticsQuery",
+    "AnalyticsResult",
+    "AsyncAnalyticsNamespace",
+    "LocalSnapshotMetadata",
+    "QueryFilter",
+    "QueryFilterOperator",
+    "QueryMeasure",
+    "QueryMeasureFunction",
+    "QueryOrderDirection",
+    "QueryOrdering",
+    "QueryReceipt",
+    "QueryScalar",
+    "QueryValue",
+    "analytics_query_document",
+    "analytics_result_document",
+    "analytics_sample_document",
+    "parse_analytics_query",
+    "parse_analytics_result",
+    "parse_analytics_sample",
+]