wandb 0.15.4__py3-none-any.whl → 0.15.5__py3-none-any.whl

wandb/integration/langchain/util.py

@@ -1,191 +0,0 @@
-"""Common utilities for the LangChain integration.
-
-This file exposes 4 primary functions:
-- `print_wandb_init_message`: Prints a message to the user when the `WandbTracer` is initialized.
-- `safely_convert_lc_run_to_wb_span`: Converts a LangChain Run into a W&B Trace Span.
-- `safely_get_span_producing_model`: Retrieves the model that produced a given LangChain Run.
-- `safely_convert_model_to_dict`: Converts a LangChain model into a dictionary.
-
-These functions are used by the `WandbTracer` to extract and save the relevant information.
-"""
-
-from typing import TYPE_CHECKING, Any, Optional, Union
-
-from langchain.callbacks.tracers.schemas import Run, RunTypeEnum
-
-import wandb
-from wandb.sdk.data_types import trace_tree
-
-if TYPE_CHECKING:
-    from langchain.chains.base import Chain
-    from langchain.llms.base import BaseLLM
-    from langchain.schema import BaseLanguageModel
-    from langchain.tools.base import BaseTool
-
-
-PRINT_WARNINGS = True
-
-
-def print_wandb_init_message(run_url: str) -> None:
-    wandb.termlog(
-        f"Streaming LangChain activity to W&B at {run_url}\n"
-        "`WandbTracer` is currently in beta.\n"
-        "Please report any issues to https://github.com/wandb/wandb/issues with the tag `langchain`."
-    )
-
-
-def safely_convert_lc_run_to_wb_span(run: Run) -> Optional["trace_tree.Span"]:
-    try:
-        return _convert_lc_run_to_wb_span(run)
-    except Exception as e:
-        if PRINT_WARNINGS:
-            wandb.termwarn(
-                f"Skipping trace saving - unable to safely convert LangChain Run into W&B Trace due to: {e}"
-            )
-    return None
-
-
-def safely_get_span_producing_model(run: Run) -> Any:
-    try:
-        return run.serialized.get("_self")
-    except Exception as e:
-        if PRINT_WARNINGS:
-            wandb.termwarn(
-                f"Skipping model saving - unable to safely retrieve LangChain model due to: {e}"
-            )
-    return None
-
-
-def safely_convert_model_to_dict(
-    model: Union["BaseLanguageModel", "BaseLLM", "BaseTool", "Chain"]
-) -> Optional[dict]:
-    """Returns the model dict if possible, otherwise returns None.
-
-    Given that Models are all user defined, this operation is not always possible.
-    """
-    data = None
-    message = None
-    try:
-        data = model.dict()
-    except Exception as e:
-        message = str(e)
-        if hasattr(model, "agent"):
-            try:
-                data = model.agent.dict()
-            except Exception as e:
-                message = str(e)
-
-    if data is not None and not isinstance(data, dict):
-        message = (
-            f"Model's dict transformation resulted in {type(data)}, expected a dict."
-        )
-        data = None
-
-    if data is not None:
-        data = _replace_type_with_kind(data)
-    else:
-        if PRINT_WARNINGS:
-            wandb.termwarn(
-                f"Skipping model saving - unable to safely convert LangChain Model to dictionary due to: {message}"
-            )
-
-    return data
-
-
-def _convert_lc_run_to_wb_span(run: "Run") -> "trace_tree.Span":
-    if run.run_type == RunTypeEnum.llm:
-        return _convert_llm_run_to_wb_span(run)
-    elif run.run_type == RunTypeEnum.chain:
-        return _convert_chain_run_to_wb_span(run)
-    elif run.run_type == RunTypeEnum.tool:
-        return _convert_tool_run_to_wb_span(run)
-    else:
-        return _convert_run_to_wb_span(run)
-
-
-def _convert_llm_run_to_wb_span(run: "Run") -> "trace_tree.Span":
-    base_span = _convert_run_to_wb_span(run)
-
-    base_span.results = [
-        trace_tree.Result(
-            inputs={"prompt": prompt},
-            outputs={
-                f"gen_{g_i}": gen["text"]
-                for g_i, gen in enumerate(run.outputs["generations"][ndx])
-            }
-            if (
-                run.outputs is not None
-                and len(run.outputs["generations"]) > ndx
-                and len(run.outputs["generations"][ndx]) > 0
-            )
-            else None,
-        )
-        for ndx, prompt in enumerate(run.inputs["prompts"] or [])
-    ]
-    base_span.span_kind = trace_tree.SpanKind.LLM
-
-    return base_span
-
-
-def _convert_chain_run_to_wb_span(run: "Run") -> "trace_tree.Span":
-    base_span = _convert_run_to_wb_span(run)
-
-    base_span.results = [trace_tree.Result(inputs=run.inputs, outputs=run.outputs)]
-    base_span.child_spans = [
-        _convert_lc_run_to_wb_span(child_run) for child_run in run.child_runs
-    ]
-    base_span.span_kind = (
-        trace_tree.SpanKind.AGENT
-        if "agent" in run.serialized.get("name").lower()
-        else trace_tree.SpanKind.CHAIN
-    )
-
-    return base_span
-
-
-def _convert_tool_run_to_wb_span(run: "Run") -> "trace_tree.Span":
-    base_span = _convert_run_to_wb_span(run)
-
-    base_span.attributes["input"] = run.inputs["input"]
-    base_span.results = [trace_tree.Result(inputs=run.inputs, outputs=run.outputs)]
-    base_span.child_spans = [
-        _convert_lc_run_to_wb_span(child_run) for child_run in run.child_runs
-    ]
-    base_span.span_kind = trace_tree.SpanKind.TOOL
-
-    return base_span
-
-
-def _convert_run_to_wb_span(run: "Run") -> "trace_tree.Span":
-    attributes = {**run.extra} if run.extra else {}
-    attributes["execution_order"] = run.execution_order
-
-    return trace_tree.Span(
-        span_id=str(run.id) if run.id is not None else None,
-        name=run.serialized.get("name"),
-        start_time_ms=int(run.start_time.timestamp() * 1000),
-        end_time_ms=int(run.end_time.timestamp() * 1000),
-        status_code=trace_tree.StatusCode.SUCCESS
-        if run.error is None
-        else trace_tree.StatusCode.ERROR,
-        status_message=run.error,
-        attributes=attributes,
-    )
-
-
-def _replace_type_with_kind(data: dict) -> dict:
-    if isinstance(data, dict):
-        # W&B TraceTree expects "_kind" instead of "_type" since `_type` is special
-        # in W&B.
-        if "_type" in data:
-            _type = data.pop("_type")
-            data["_kind"] = _type
-        return {k: _replace_type_with_kind(v) for k, v in data.items()}
-    elif isinstance(data, list):
-        return [_replace_type_with_kind(v) for v in data]
-    elif isinstance(data, tuple):
-        return tuple(_replace_type_with_kind(v) for v in data)
-    elif isinstance(data, set):
-        return {_replace_type_with_kind(v) for v in data}
-    else:
-        return data

wandb/sdk/artifacts/invalid_artifact.py

@@ -1,23 +0,0 @@
-"""Invalid artifact."""
-from typing import TYPE_CHECKING, Any
-
-from wandb.sdk.artifacts.exceptions import ArtifactNotLoggedError
-
-if TYPE_CHECKING:
-    from wandb.sdk.artifacts.artifact import Artifact as ArtifactInterface
-
-
-class InvalidArtifact:
-    """An "artifact" that raises an error when any properties are accessed."""
-
-    def __init__(self, base_artifact: "ArtifactInterface"):
-        super().__setattr__("base_artifact", base_artifact)
-
-    def __getattr__(self, __name: str) -> Any:
-        raise ArtifactNotLoggedError(artifact=self.base_artifact, attr=__name)
-
-    def __setattr__(self, __name: str, __value: Any) -> None:
-        raise ArtifactNotLoggedError(artifact=self.base_artifact, attr=__name)
-
-    def __bool__(self) -> bool:
-        return False

wandb/sdk/artifacts/lazy_artifact.py

@@ -1,162 +0,0 @@
-"""Lazy artifact."""
-from typing import TYPE_CHECKING, Any, List, Optional, Union
-
-from wandb.apis import PublicApi
-from wandb.sdk.artifacts.artifact import Artifact as ArtifactInterface
-from wandb.sdk.artifacts.exceptions import WaitTimeoutError
-from wandb.sdk.artifacts.invalid_artifact import InvalidArtifact
-from wandb.sdk.artifacts.public_artifact import Artifact as PublicArtifact
-from wandb.sdk.lib.paths import FilePathStr, StrPath
-
-if TYPE_CHECKING:
-    import wandb.apis.public
-    from wandb.data_types import WBValue
-    from wandb.sdk.artifacts.artifact_manifest import ArtifactManifest
-    from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
-
-
-class LazyArtifact(ArtifactInterface):
-    _api: PublicApi
-    _instance: Union[ArtifactInterface, InvalidArtifact]
-    _future: Any
-
-    def __init__(self, api: PublicApi, future: Any):
-        self._api = api
-        self._instance = InvalidArtifact(self)
-        self._future = future
-
-    def __getattr__(self, item: str) -> Any:
-        return getattr(self._instance, item)
-
-    def wait(self, timeout: Optional[int] = None) -> ArtifactInterface:
-        if not self._instance:
-            future_get = self._future.get(timeout)
-            if not future_get:
-                raise WaitTimeoutError(
-                    "Artifact upload wait timed out, failed to fetch Artifact response"
-                )
-            resp = future_get.response.log_artifact_response
-            if resp.error_message:
-                raise ValueError(resp.error_message)
-            instance = PublicArtifact.from_id(resp.artifact_id, self._api.client)
-            assert instance is not None
-            self._instance = instance
-        assert isinstance(
-            self._instance, ArtifactInterface
-        ), "Insufficient permissions to fetch Artifact with id {} from {}".format(
-            resp.artifact_id, self._api.client.app_url
-        )
-        return self._instance
-
-    @property
-    def id(self) -> Optional[str]:
-        return self._instance.id
-
-    @property
-    def entity(self) -> str:
-        return self._instance.entity
-
-    @property
-    def project(self) -> str:
-        return self._instance.project
-
-    @property
-    def name(self) -> str:
-        return self._instance.name
-
-    @property
-    def version(self) -> str:
-        return self._instance.version
-
-    @property
-    def source_entity(self) -> str:
-        return self._instance.source_entity
-
-    @property
-    def source_project(self) -> str:
-        return self._instance.source_project
-
-    @property
-    def source_name(self) -> str:
-        return self._instance.source_name
-
-    @property
-    def source_version(self) -> str:
-        return self._instance.source_version
-
-    @property
-    def type(self) -> str:
-        return self._instance.type
-
-    @property
-    def manifest(self) -> "ArtifactManifest":
-        return self._instance.manifest
-
-    @property
-    def digest(self) -> str:
-        return self._instance.digest
-
-    @property
-    def state(self) -> str:
-        return self._instance.state
-
-    @property
-    def size(self) -> int:
-        return self._instance.size
-
-    @property
-    def commit_hash(self) -> str:
-        return self._instance.commit_hash
-
-    @property
-    def description(self) -> Optional[str]:
-        return self._instance.description
-
-    @description.setter
-    def description(self, desc: Optional[str]) -> None:
-        self._instance.description = desc
-
-    @property
-    def metadata(self) -> dict:
-        return self._instance.metadata
-
-    @metadata.setter
-    def metadata(self, metadata: dict) -> None:
-        self._instance.metadata = metadata
-
-    @property
-    def aliases(self) -> List[str]:
-        return self._instance.aliases
-
-    @aliases.setter
-    def aliases(self, aliases: List[str]) -> None:
-        self._instance.aliases = aliases
-
-    def used_by(self) -> List["wandb.apis.public.Run"]:
-        return self._instance.used_by()
-
-    def logged_by(self) -> Optional["wandb.apis.public.Run"]:
-        return self._instance.logged_by()
-
-    def get_path(self, name: StrPath) -> "ArtifactManifestEntry":
-        return self._instance.get_path(name)
-
-    def get(self, name: str) -> Optional["WBValue"]:
-        return self._instance.get(name)
-
-    def download(
-        self, root: Optional[str] = None, recursive: bool = False
-    ) -> FilePathStr:
-        return self._instance.download(root, recursive)
-
-    def checkout(self, root: Optional[str] = None) -> str:
-        return self._instance.checkout(root)
-
-    def verify(self, root: Optional[str] = None) -> None:
-        self._instance.verify(root)
-
-    def save(self) -> None:
-        self._instance.save()
-
-    def delete(self, delete_aliases: bool = False) -> None:
-        self._instance.delete(delete_aliases=delete_aliases)