arize-phoenix 3.16.1__py3-none-any.whl → 7.7.0__py3-none-any.whl

phoenix/storage/span_store/__init__.py

@@ -1,23 +0,0 @@
-from pathlib import Path
-from typing import Callable, Iterator, Mapping, Protocol
-
-from opentelemetry.proto.trace.v1.trace_pb2 import TracesData
-
-from phoenix.config import SpanStorageType
-from phoenix.storage.span_store.text_file import TextFileSpanStoreImpl
-
-
-class SpanStore(Protocol):
-    def save(self, req: TracesData) -> None: ...
-
-    def load(self) -> Iterator[TracesData]: ...
-
-
-SPAN_STORE_FACTORIES: Mapping[SpanStorageType, Callable[[Path], SpanStore]] = {
-    SpanStorageType.TEXT_FILES: TextFileSpanStoreImpl,
-}
-
-__all__ = (
-    "SpanStore",
-    "SPAN_STORE_FACTORIES",
-)

phoenix/storage/span_store/text_file.py

@@ -1,85 +0,0 @@
-import weakref
-from base64 import urlsafe_b64decode, urlsafe_b64encode
-from pathlib import Path
-from queue import SimpleQueue
-from threading import Thread
-from typing import Iterator, Optional, Tuple
-
-from opentelemetry.proto.trace.v1.trace_pb2 import TracesData
-from typing_extensions import TypeAlias
-
-from phoenix.utilities.project import get_project_name
-
-_Queue: TypeAlias = "SimpleQueue[Optional[TracesData]]"
-
-_END_OF_QUEUE = None
-_DIR_PREFIX = "project."
-
-
-class TextFileSpanStoreImpl:
-    def __init__(self, root: Path) -> None:
-        self._root = root
-        self._projects = dict(_load_projects(self._root))
-
-    def save(self, traces_data: TracesData) -> None:
-        for resource_spans in traces_data.resource_spans:
-            name = get_project_name(resource_spans.resource.attributes)
-            if (project := self._projects.get(name)) is None:
-                self._projects[name] = project = _Project(name, self._root)
-            project.save(TracesData(resource_spans=[resource_spans]))
-
-    def load(self) -> Iterator[TracesData]:
-        queue: _Queue = SimpleQueue()
-        Thread(target=self._load_traces_data, args=(queue,)).start()
-        while (item := queue.get()) is not _END_OF_QUEUE:
-            yield item
-
-    def _load_traces_data(self, queue: _Queue) -> None:
-        """Load traces data from all projects into the queue"""
-        for project in self._projects.values():
-            project.load(queue)
-        queue.put(_END_OF_QUEUE)
-
-
-class _Project:
-    def __init__(self, name: str, root: Path) -> None:
-        self._path = root / f"project.{_b64encode(name.encode())}"
-        spans_path = self._path / "spans"
-        spans_path.mkdir(parents=True, exist_ok=True)
-        self._spans = _Spans(spans_path / "spans.txt")
-
-    def save(self, traces_data: TracesData) -> None:
-        self._spans.save(traces_data)
-
-    def load(self, queue: _Queue) -> None:
-        self._spans.load(queue)
-
-
-class _Spans:
-    def __init__(self, file_path: Path):
-        self._path = file_path
-        self._file = self._path.open("a")
-        weakref.finalize(self, self._file.close)
-
-    def save(self, traces_data: TracesData) -> None:
-        self._file.write(_b64encode(traces_data.SerializeToString()))
-        self._file.write("\n")
-
-    def load(self, queue: _Queue) -> None:
-        with self._path.open("r") as f:
-            while line := f.readline():
-                queue.put(TracesData.FromString(_b64decode(line)))
-
-
-def _load_projects(root: Path) -> Iterator[Tuple[str, _Project]]:
-    for dir_path in root.glob(f"{_DIR_PREFIX}*/"):
-        name = _b64decode(dir_path.name[len(_DIR_PREFIX) :]).decode()
-        yield name, _Project(name, root)
-
-
-def _b64encode(s: bytes) -> str:
-    return urlsafe_b64encode(s).decode()
-
-
-def _b64decode(name: str) -> bytes:
-    return urlsafe_b64decode(name.encode())

phoenix/trace/dsl/missing.py

@@ -1,60 +0,0 @@
-from typing import Any
-
-
-class _Missing:
-    """
-    Falsify all comparisons except those with self; return self when getattr()
-    is called. Also, self is callable returning self. All this may seem peculiar
-    but is useful for getting the desired (and intuitive) behavior from any
-    boolean (i.e. comparative) expression without needing error handling when
-    missing values are encountered. `_Missing()` is intended to be a (fancier)
-    replacement for `None`.
-    """
-
-    def __lt__(self, _: Any) -> bool:
-        return False
-
-    def __le__(self, _: Any) -> bool:
-        return False
-
-    def __gt__(self, _: Any) -> bool:
-        return False
-
-    def __ge__(self, _: Any) -> bool:
-        return False
-
-    def __eq__(self, other: Any) -> bool:
-        return isinstance(other, _Missing)
-
-    def __ne__(self, _: Any) -> bool:
-        return False
-
-    def __len__(self) -> int:
-        return 0
-
-    def __iter__(self) -> Any:
-        return self
-
-    def __next__(self) -> Any:
-        raise StopIteration()
-
-    def __contains__(self, _: Any) -> bool:
-        return False
-
-    def __str__(self) -> str:
-        return ""
-
-    def __float__(self) -> float:
-        return float("nan")
-
-    def __bool__(self) -> bool:
-        return False
-
-    def __getattr__(self, _: Any) -> "_Missing":
-        return self
-
-    def __call__(self, *_: Any, **__: Any) -> "_Missing":
-        return self
-
-
-MISSING: Any = _Missing()

phoenix/trace/langchain/__init__.py

@@ -1,3 +0,0 @@
-from phoenix.trace.langchain.instrumentor import LangChainInstrumentor
-
-__all__ = ("LangChainInstrumentor",)

phoenix/trace/langchain/instrumentor.py

@@ -1,35 +0,0 @@
-import logging
-from importlib.metadata import PackageNotFoundError
-from importlib.util import find_spec
-from typing import Any
-
-from openinference.instrumentation.langchain import LangChainInstrumentor as Instrumentor
-from openinference.semconv.resource import ResourceAttributes
-from opentelemetry.sdk import trace as trace_sdk
-from opentelemetry.sdk.resources import Resource
-from opentelemetry.sdk.trace.export import SimpleSpanProcessor
-
-from phoenix.config import get_env_project_name
-from phoenix.trace.exporter import _OpenInferenceExporter
-
-logger = logging.getLogger(__name__)
-
-
-__all__ = ("LangChainInstrumentor",)
-
-
-class LangChainInstrumentor(Instrumentor):
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        if find_spec("langchain_core") is None:
-            raise PackageNotFoundError(
-                "Missing `langchain-core`. Install with `pip install langchain-core`."
-            )
-        super().__init__()
-
-    def instrument(self) -> None:
-        tracer_provider = trace_sdk.TracerProvider(
-            resource=Resource({ResourceAttributes.PROJECT_NAME: get_env_project_name()}),
-            span_limits=trace_sdk.SpanLimits(max_attributes=10_000),
-        )
-        tracer_provider.add_span_processor(SimpleSpanProcessor(_OpenInferenceExporter()))
-        super().instrument(skip_dep_check=True, tracer_provider=tracer_provider)

phoenix/trace/llama_index/__init__.py

@@ -1,3 +0,0 @@
-from .callback import OpenInferenceTraceCallbackHandler
-
-__all__ = ["OpenInferenceTraceCallbackHandler"]

phoenix/trace/llama_index/callback.py

@@ -1,102 +0,0 @@
-import logging
-from importlib.metadata import PackageNotFoundError, version
-from typing import Any, Optional, Tuple
-
-from openinference.semconv.resource import ResourceAttributes
-from opentelemetry import trace as trace_api
-from opentelemetry.sdk import trace as trace_sdk
-from opentelemetry.sdk.resources import Resource
-from opentelemetry.sdk.trace.export import SimpleSpanProcessor
-
-from phoenix.config import get_env_project_name
-from phoenix.trace.errors import IncompatibleLibraryVersionError
-from phoenix.trace.exporter import _OpenInferenceExporter
-
-logger = logging.getLogger(__name__)
-
-LLAMA_INDEX_MODERN_VERSION = (0, 10, 0)
-INSTRUMENTATION_MODERN_VERSION = (1, 0, 0)
-
-
-def _check_instrumentation_compatibility() -> bool:
-    llama_index_version_str = _get_version_if_installed("llama-index")
-    llama_index_installed = llama_index_version_str is not None
-    llama_index_core_version_str = _get_version_if_installed("llama-index-core")
-    llama_index_core_installed = modern_llama_index_installed = (
-        llama_index_core_version_str is not None
-    )
-    instrumentation_version_str = version("openinference-instrumentation-llama-index")
-    instrumentation_version = _parse_semantic_version(instrumentation_version_str)
-
-    if not llama_index_installed and not llama_index_core_installed:
-        raise PackageNotFoundError(
-            "Missing `llama_index`. "
-            "Install with `pip install llama-index` or "
-            "`pip install llama-index-core` for a minimal installation."
-        )
-    elif modern_llama_index_installed and instrumentation_version < INSTRUMENTATION_MODERN_VERSION:
-        raise IncompatibleLibraryVersionError(
-            f"llama-index-core v{llama_index_core_version_str} is not compatible with "
-            f"openinference-instrumentation-llama-index v{instrumentation_version_str}. "
-            "Please upgrade openinference-instrumentation-llama-index to at least 1.0.0 via "
-            "`pip install 'openinference-instrumentation-llama-index>=1.0.0'`."
-        )
-    elif (
-        llama_index_installed
-        and llama_index_version_str
-        and _parse_semantic_version(llama_index_version_str) < LLAMA_INDEX_MODERN_VERSION
-        and instrumentation_version >= INSTRUMENTATION_MODERN_VERSION
-    ):
-        raise IncompatibleLibraryVersionError(
-            f"llama-index v{llama_index_version_str} is not compatible with "
-            f"openinference-instrumentation-llama-index v{instrumentation_version_str}. "
-            "Please either migrate llama-index to at least 0.10.0 or downgrade "
-            "openinference-instrumentation-llama-index via "
-            "`pip install 'openinference-instrumentation-llama-index<1.0.0'`."
-        )
-    return True
-
-
-def _get_version_if_installed(package_name: str) -> Optional[str]:
-    """
-    Gets the version of the package if it is installed, otherwise, returns None.
-    """
-    try:
-        return version(package_name)
-    except PackageNotFoundError:
-        return None
-
-
-def _parse_semantic_version(semver_string: str) -> Tuple[int, ...]:
-    """
-    Parse a semantic version string into a tuple of integers.
-    """
-    return tuple(map(int, semver_string.split(".")[:3]))
-
-
-if _check_instrumentation_compatibility():
-    from openinference.instrumentation.llama_index._callback import (
-        OpenInferenceTraceCallbackHandler as _OpenInferenceTraceCallbackHandler,
-    )
-    from openinference.instrumentation.llama_index.version import (
-        __version__,
-    )
-
-
-class OpenInferenceTraceCallbackHandler(_OpenInferenceTraceCallbackHandler):
-    """Callback handler for storing LLM application trace data in OpenInference format.
-    OpenInference is an open standard for capturing and storing AI model
-    inferences. It enables production LLMapp servers to seamlessly integrate
-    with LLM observability solutions such as Arize and Phoenix.
-
-    For more information on the specification, see
-    https://github.com/Arize-ai/openinference
-    """
-
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        tracer_provider = trace_sdk.TracerProvider(
-            resource=Resource({ResourceAttributes.PROJECT_NAME: get_env_project_name()}),
-            span_limits=trace_sdk.SpanLimits(max_attributes=10_000),
-        )
-        tracer_provider.add_span_processor(SimpleSpanProcessor(_OpenInferenceExporter()))
-        super().__init__(trace_api.get_tracer(__name__, __version__, tracer_provider))

phoenix/trace/openai/__init__.py

@@ -1,3 +0,0 @@
-from .instrumentor import OpenAIInstrumentor
-
-__all__ = ["OpenAIInstrumentor"]

phoenix/trace/openai/instrumentor.py

@@ -1,30 +0,0 @@
-import logging
-from importlib.metadata import PackageNotFoundError
-from importlib.util import find_spec
-from typing import Any
-
-from openinference.instrumentation.openai import OpenAIInstrumentor as Instrumentor
-from openinference.semconv.resource import ResourceAttributes
-from opentelemetry.sdk import trace as trace_sdk
-from opentelemetry.sdk.resources import Resource
-from opentelemetry.sdk.trace.export import SimpleSpanProcessor
-
-from phoenix.config import get_env_project_name
-from phoenix.trace.exporter import _OpenInferenceExporter
-
-logger = logging.getLogger(__name__)
-
-
-class OpenAIInstrumentor(Instrumentor):
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        if find_spec("openai") is None:
-            raise PackageNotFoundError("Missing `openai`. Install with `pip install openai`.")
-        super().__init__()
-
-    def instrument(self) -> None:
-        tracer_provider = trace_sdk.TracerProvider(
-            resource=Resource({ResourceAttributes.PROJECT_NAME: get_env_project_name()}),
-            span_limits=trace_sdk.SpanLimits(max_attributes=10_000),
-        )
-        tracer_provider.add_span_processor(SimpleSpanProcessor(_OpenInferenceExporter()))
-        super().instrument(skip_dep_check=True, tracer_provider=tracer_provider)