coco-framework 0.1.0__py3-none-any.whl

coco_graph/typing.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing_extensions import TypeVar
+
+from coco_graph._internal._typing import StateLike
+
+__all__ = (
+    "StateT",
+    "StateT_co",
+    "StateT_contra",
+    "InputT",
+    "OutputT",
+    "ContextT",
+)
+
+StateT = TypeVar("StateT", bound=StateLike)
+"""Type variable used to represent the state in a graph."""
+
+StateT_co = TypeVar("StateT_co", bound=StateLike, covariant=True)
+
+StateT_contra = TypeVar("StateT_contra", bound=StateLike, contravariant=True)
+
+ContextT = TypeVar("ContextT", bound=StateLike | None, default=None)
+"""Type variable used to represent graph run scoped context.
+
+Defaults to `None`.
+"""
+
+ContextT_contra = TypeVar(
+    "ContextT_contra", bound=StateLike | None, contravariant=True, default=None
+)
+
+InputT = TypeVar("InputT", bound=StateLike, default=StateT)
+"""Type variable used to represent the input to a `StateGraph`.
+
+Defaults to `StateT`.
+"""
+
+OutputT = TypeVar("OutputT", bound=StateLike, default=StateT)
+"""Type variable used to represent the output of a `StateGraph`.
+
+Defaults to `StateT`.
+"""
+
+NodeInputT = TypeVar("NodeInputT", bound=StateLike)
+"""Type variable used to represent the input to a node."""
+
+NodeInputT_contra = TypeVar("NodeInputT_contra", bound=StateLike, contravariant=True)

coco_graph/utils/__init__.py

@@ -0,0 +1 @@
+"""Legacy utilities module, to be removed in v1."""

coco_graph/utils/config.py

@@ -0,0 +1,4 @@
+"""Backwards compat imports for config utilities, to be removed in v1."""
+
+from coco_graph._internal._config import ensure_config, patch_configurable  # noqa: F401
+from coco_graph.config import get_config, get_store  # noqa: F401

coco_graph/utils/runnable.py

@@ -0,0 +1,3 @@
+"""Backwards compat imports for runnable utilities, to be removed in v1."""
+
+from coco_graph._internal._runnable import RunnableCallable, RunnableLike  # noqa: F401

coco_graph/version.py

@@ -0,0 +1,13 @@
+"""Exports package version."""
+
+from importlib import metadata
+
+__all__ = ("__version__",)
+
+for _dist in ("trustcoco-graph", "coco-framework", __package__ or "coco_graph"):
+    try:
+        __version__ = metadata.version(_dist)
+        break
+    except metadata.PackageNotFoundError:
+        __version__ = ""
+del _dist, metadata  # optional, avoids polluting the results of dir(__package__)

coco_graph/warnings.py

@@ -0,0 +1,69 @@
+"""CocoGraph specific warnings."""
+
+from __future__ import annotations
+
+__all__ = (
+    "CocoGraphDeprecationWarning",
+    "CocoGraphDeprecatedSinceV05",
+    "CocoGraphDeprecatedSinceV10",
+    "CocoGraphDeprecatedSinceV11",
+)
+
+
+class CocoGraphDeprecationWarning(DeprecationWarning):
+    """A CocoGraph specific deprecation warning.
+
+    Attributes:
+        message: Description of the warning.
+        since: CocoGraph version in which the deprecation was introduced.
+        expected_removal: CocoGraph version in what the corresponding functionality expected to be removed.
+
+    Inspired by the Pydantic `PydanticDeprecationWarning` class, which sets a great standard
+    for deprecation warnings with clear versioning information.
+    """
+
+    message: str
+    since: tuple[int, int]
+    expected_removal: tuple[int, int]
+
+    def __init__(
+        self,
+        message: str,
+        *args: object,
+        since: tuple[int, int],
+        expected_removal: tuple[int, int] | None = None,
+    ) -> None:
+        super().__init__(message, *args)
+        self.message = message.rstrip(".")
+        self.since = since
+        self.expected_removal = (
+            expected_removal if expected_removal is not None else (since[0] + 1, 0)
+        )
+
+    def __str__(self) -> str:
+        message = (
+            f"{self.message}. Deprecated in CocoGraph V{self.since[0]}.{self.since[1]}"
+            f" to be removed in V{self.expected_removal[0]}.{self.expected_removal[1]}."
+        )
+        return message
+
+
+class CocoGraphDeprecatedSinceV05(CocoGraphDeprecationWarning):
+    """A specific `CocoGraphDeprecationWarning` subclass defining functionality deprecated since CocoGraph v0.5.0"""
+
+    def __init__(self, message: str, *args: object) -> None:
+        super().__init__(message, *args, since=(0, 5), expected_removal=(2, 0))
+
+
+class CocoGraphDeprecatedSinceV10(CocoGraphDeprecationWarning):
+    """A specific `CocoGraphDeprecationWarning` subclass defining functionality deprecated since CocoGraph v1.0.0"""
+
+    def __init__(self, message: str, *args: object) -> None:
+        super().__init__(message, *args, since=(1, 0), expected_removal=(2, 0))
+
+
+class CocoGraphDeprecatedSinceV11(CocoGraphDeprecationWarning):
+    """A specific `CocoGraphDeprecationWarning` subclass defining functionality deprecated since CocoGraph v1.1.0"""
+
+    def __init__(self, message: str, *args: object) -> None:
+        super().__init__(message, *args, since=(1, 1), expected_removal=(3, 0))

coco_openai/__init__.py

@@ -0,0 +1,20 @@
+"""Module for OpenAI integrations."""
+
+from coco_openai._version import __version__
+from coco_openai.chat_models import AzureChatOpenAI, ChatOpenAI
+from coco_openai.chat_models._client_utils import StreamChunkTimeoutError
+from coco_openai.embeddings import AzureOpenAIEmbeddings, OpenAIEmbeddings
+from coco_openai.llms import AzureOpenAI, OpenAI
+from coco_openai.tools import custom_tool
+
+__all__ = [
+    "AzureChatOpenAI",
+    "AzureOpenAI",
+    "AzureOpenAIEmbeddings",
+    "ChatOpenAI",
+    "OpenAI",
+    "OpenAIEmbeddings",
+    "StreamChunkTimeoutError",
+    "__version__",
+    "custom_tool",
+]

coco_openai/_compat.py

@@ -0,0 +1,45 @@
+"""Resolve the `httpx` library matching the installed `openai` SDK.
+
+`openai>=3` is backed by `httpx2` (an API-identical drop-in for `httpx`),
+`openai<3` by `httpx`. Transport/config objects injected into the SDK client
+are built from the same library, so this module re-exports whichever one the
+installed SDK version defaults to.
+
+Import `httpx` from here **only** for objects handed to the OpenAI SDK client
+(e.g. a custom transport, `Limits`, `Proxy`, or `http_client=`). Standalone HTTP
+code should import `httpx` directly.
+
+Note: the SDK's `DefaultHttpxClient`/`DefaultAsyncHttpxClient` classes are *not*
+re-exported here — they are subclassable in both SDK versions (backed by
+`httpx2` on `openai>=3`), so subclass `openai.DefaultHttpxClient` directly. The
+`DefaultHttpx2Client` names are factory functions, not classes, and cannot be
+subclassed.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+import openai
+
+
+def _sdk_uses_httpx2() -> bool:
+    """Whether the installed `openai` SDK defaults to `httpx2` (openai>=3)."""
+    # First integer run, so tag-derived strings like `v3.0.0` still parse;
+    # unparseable falls back to classic httpx (always present).
+    match = re.match(r"\D*(\d+)", str(getattr(openai, "__version__", "")))
+    return match is not None and int(match.group(1)) >= 3
+
+
+if TYPE_CHECKING:
+    # Type-check against `httpx`, whose API `httpx2` mirrors. This keeps mypy
+    # working in the lint environment (which installs `httpx`, not `httpx2`)
+    # while the runtime selection below picks the correct module.
+    import httpx
+elif _sdk_uses_httpx2():
+    import httpx2 as httpx  # type: ignore[import-not-found]
+else:
+    import httpx
+
+__all__ = ["httpx"]

coco_openai/_version.py

@@ -0,0 +1,3 @@
+"""Version information for `trustcoco-openai`."""
+
+__version__ = "1.6.6"

coco_openai/chat_models/__init__.py

@@ -0,0 +1,6 @@
+"""Module for OpenAI chat models."""
+
+from coco_openai.chat_models.azure import AzureChatOpenAI
+from coco_openai.chat_models.base import ChatOpenAI
+
+__all__ = ["AzureChatOpenAI", "ChatOpenAI"]