calc-flow-python 2026.9.24__cp39-abi3-win_amd64.whl

calc_flow/__init__.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+from calc_flow import _native as _native
+from calc_flow import symbolic
+from calc_flow.array import register_jax, register_numpy
+from calc_flow.asof_join_spec import AsofJoinSide, AsofJoinSpec, AsofStateLimits
+from calc_flow.capabilities import (
+    CapabilityRule,
+    ConnectorCapabilities,
+    ConnectorCapability,
+    OperatorCapability,
+    ProviderArrayRules,
+    ProviderCapability,
+    ProviderOption,
+    ProviderOptionsSchema,
+    ProviderPort,
+    RuntimeCapabilities,
+    RuntimeSessionScope,
+    UdfCapability,
+    connector_capabilities,
+)
+from calc_flow.compute import compute, compute_async
+from calc_flow.config import ProjectDocument
+from calc_flow.errors import (
+    CalcFlowError,
+    CancelledError,
+    CheckpointError,
+    CheckpointPublicationUnknownError,
+    CompileError,
+    ConfigError,
+    ExecutionError,
+    ProviderError,
+    StreamingRuntimeError,
+)
+from calc_flow.pipeline import (
+    ArrowFieldSpec,
+    BatchExecutionPlan,
+    DeliveryGuarantee,
+    ExecutionPlan,
+    JoinStateLimits,
+    JoinTimeBounds,
+    PipelineBuilder,
+    Runtime,
+    StreamExecutionPlan,
+    StreamRequirements,
+    compile_stream_project,
+    project_json_schema,
+    validate_project_json,
+)
+from calc_flow.runtime import (
+    BoundedOutOfOrderness,
+    Cursor,
+    Data,
+    DisabledWatermarks,
+    EdgeBudget,
+    EpochIdempotentDelivery,
+    Idle,
+    JobOutcome,
+    JobStatus,
+    JSONValue,
+    ManagedCheckpointRuntime,
+    NativeWatermarkCapability,
+    OrdinaryDelivery,
+    ReplayPositioning,
+    RollingCallbackMetrics,
+    RollingMetrics,
+    SinkBinding,
+    SinkDelivery,
+    SinkRecovery,
+    SourceBinding,
+    SourceCapabilities,
+    SourceDeliveryCapability,
+    SourceEvent,
+    SourceProvidedWatermarks,
+    StreamingError,
+    StreamingFailureReasonCode,
+    StreamingJob,
+    StreamingRunner,
+    StreamRuntimeConfig,
+    StreamSink,
+    StreamSource,
+    TransactionalDelivery,
+    TransactionalStreamSink,
+    Watermark,
+    WatermarkPolicy,
+)
+from calc_flow.store import FileProjectStore
+from calc_flow.stream import StreamInput, StreamOutput, StreamResults
+from calc_flow.symbolic import (
+    AnalysisIssue,
+    AnalysisResult,
+    ArrayExpr,
+    ColumnExpr,
+    CrossSectionGroup,
+    DurationFrame,
+    EventTimeBucket,
+    Expr,
+    FeatureSet,
+    Field,
+    LateOutputs,
+    Parameter,
+    Program,
+    RowFrame,
+    TableExpr,
+    WindowAggregate,
+    cs,
+    duration,
+    event_time_bucket,
+    exact_time,
+    linalg,
+    lit,
+    parameter,
+    row,
+    rows,
+    sql,
+    table,
+    table_input,
+    ts,
+    window,
+    with_late_output,
+)
+
+__version__ = "2026.9.24"
+Batch = _native.Batch
+ExecutionOptions = _native.ExecutionOptions
+ProviderContext = _native.ProviderContext
+RunResult = _native.RunResult
+__all__ = [
+    "AsofJoinSide",
+    "AsofJoinSpec",
+    "AsofStateLimits",
+    "compute",
+    "compute_async",
+    "sql",
+    "StreamInput",
+    "StreamOutput",
+    "StreamResults",
+    "Expr",
+    "ColumnExpr",
+    "TableExpr",
+    "ArrayExpr",
+    "LateOutputs",
+    "with_late_output",
+    "Parameter",
+    "Field",
+    "FeatureSet",
+    "Program",
+    "table_input",
+    "parameter",
+    "lit",
+    "row",
+    "ts",
+    "cs",
+    "table",
+    "linalg",
+    "window",
+    "rows",
+    "duration",
+    "exact_time",
+    "event_time_bucket",
+    "RowFrame",
+    "DurationFrame",
+    "CrossSectionGroup",
+    "EventTimeBucket",
+    "WindowAggregate",
+    "AnalysisIssue",
+    "AnalysisResult",
+    "Batch",
+    "ArrowFieldSpec",
+    "BatchExecutionPlan",
+    "BoundedOutOfOrderness",
+    "CalcFlowError",
+    "CancelledError",
+    "CheckpointError",
+    "CheckpointPublicationUnknownError",
+    "CompileError",
+    "ConfigError",
+    "Cursor",
+    "Data",
+    "DisabledWatermarks",
+    "EdgeBudget",
+    "EpochIdempotentDelivery",
+    "ExecutionError",
+    "ExecutionOptions",
+    "DeliveryGuarantee",
+    "FileProjectStore",
+    "Idle",
+    "JobOutcome",
+    "JobStatus",
+    "RollingCallbackMetrics",
+    "RollingMetrics",
+    "JSONValue",
+    "JoinStateLimits",
+    "JoinTimeBounds",
+    "ManagedCheckpointRuntime",
+    "NativeWatermarkCapability",
+    "OrdinaryDelivery",
+    "ProviderError",
+    "ProviderContext",
+    "ProjectDocument",
+    "ExecutionPlan",
+    "PipelineBuilder",
+    "ConnectorCapabilities",
+    "ConnectorCapability",
+    "CapabilityRule",
+    "OperatorCapability",
+    "connector_capabilities",
+    "compile_stream_project",
+    "ProviderArrayRules",
+    "ProviderCapability",
+    "ProviderOption",
+    "ProviderOptionsSchema",
+    "ProviderPort",
+    "Runtime",
+    "RuntimeCapabilities",
+    "RuntimeSessionScope",
+    "RunResult",
+    "ReplayPositioning",
+    "SinkBinding",
+    "SinkDelivery",
+    "SinkRecovery",
+    "SourceBinding",
+    "SourceCapabilities",
+    "SourceDeliveryCapability",
+    "SourceEvent",
+    "SourceProvidedWatermarks",
+    "StreamRuntimeConfig",
+    "StreamSink",
+    "StreamSource",
+    "StreamingError",
+    "StreamingFailureReasonCode",
+    "StreamingJob",
+    "StreamingRunner",
+    "StreamingRuntimeError",
+    "StreamExecutionPlan",
+    "StreamRequirements",
+    "TransactionalDelivery",
+    "TransactionalStreamSink",
+    "UdfCapability",
+    "register_jax",
+    "register_numpy",
+    "symbolic",
+    "project_json_schema",
+    "validate_project_json",
+    "Watermark",
+    "WatermarkPolicy",
+    "__version__",
+]

calc_flow/_compat.py

@@ -0,0 +1,103 @@
+"""Python-version support for slotted frozen data containers."""
+
+from __future__ import annotations
+
+import sys
+from builtins import zip as _builtin_zip
+from dataclasses import dataclass as _stdlib_dataclass
+from dataclasses import fields
+from enum import Enum
+from itertools import zip_longest
+from typing import Any
+
+if sys.version_info >= (3, 12):
+    from typing import TypeAliasType as TypeAliasType
+else:
+    from typing_extensions import TypeAliasType as TypeAliasType
+
+if sys.version_info >= (3, 10):
+    dataclass = _stdlib_dataclass
+else:
+
+    def _inherited_slots(cls: type) -> set[str]:
+        return {
+            name
+            for base in cls.__mro__[1:]
+            for name in (
+                (base.__slots__,)
+                if isinstance(getattr(base, "__slots__", ()), str)
+                else getattr(base, "__slots__", ())
+            )
+        }
+
+    def _install_frozen_pickle(slotted: type, namespace: dict[str, Any]) -> None:
+        def getstate(self: object) -> list[object]:
+            return [getattr(self, item.name) for item in fields(self)]
+
+        def setstate(self: object, values: list[object]) -> None:
+            for item, value in zip(fields(self), values):
+                object.__setattr__(self, item.name, value)
+
+        if "__getstate__" not in namespace:
+            slotted.__getstate__ = getstate
+        if "__setstate__" not in namespace:
+            slotted.__setstate__ = setstate
+
+    def _slotted_dataclass(result: type, *, frozen: bool) -> type:
+        if "__slots__" in result.__dict__:
+            raise TypeError(f"{result.__name__} already specifies __slots__")
+
+        names = tuple(item.name for item in fields(result))
+        inherited = _inherited_slots(result)
+        namespace = dict(result.__dict__)
+        namespace["__slots__"] = tuple(name for name in names if name not in inherited)
+        for name in names:
+            namespace.pop(name, None)
+        namespace.pop("__dict__", None)
+        namespace.pop("__weakref__", None)
+        slotted = type(result)(result.__name__, result.__bases__, namespace)
+        slotted.__qualname__ = result.__qualname__
+        if frozen:
+            _install_frozen_pickle(slotted, namespace)
+        return slotted
+
+    def dataclass(*, slots: bool = False, **options: Any) -> Any:
+        """Build stdlib data classes with slots on Python 3.9."""
+
+        def decorate(cls: type) -> type:
+            result = _stdlib_dataclass(cls, **options)
+            if slots:
+                return _slotted_dataclass(result, frozen=bool(options.get("frozen")))
+            return result
+
+        return decorate
+
+
+if sys.version_info >= (3, 11):
+    from enum import StrEnum as StrEnum
+else:
+
+    class StrEnum(str, Enum):
+        """String-valued enum with the standard string representation."""
+
+        __str__ = str.__str__
+
+
+if sys.version_info >= (3, 10):
+    zip = _builtin_zip
+else:
+
+    def zip(*iterables: Any, strict: bool = False) -> Any:
+        """Preserve strict zip validation on Python 3.9."""
+        if not strict:
+            return _builtin_zip(*iterables)
+
+        sentinel = object()
+
+        def rows() -> Any:
+            for values in zip_longest(*iterables, fillvalue=sentinel):
+                if any(value is sentinel for value in values):
+                    raise ValueError("zip() arguments have different lengths")
+                yield values
+
+        return rows()

calc_flow/_native.pyd

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: calc_flow/_native.pyd
+size: 149237248 bytes
+sha256: 3df4642a7500ab0ae16702344d0d06c48579db8f9a2fa65fbe74a7c15756f125