[Python] 0.1.64 |Accept RunnableConfig|Customize OAI wrapper name|@Tr…

…aceable typing|Cache default RunTree Client

## Read parent run info from RunnableConfig if passed to function decorated with traceable

- pass config into wrapped func only if signature declares it
- modify signature of wrapper func to declare config as a kw arg,
otherwise runnables don't pass it in
- extract client and project_name from tracer, in addition to parent run
info
- update as_runnable to delegate run tree creation to new method


## Custom Run Name support in OpenAI Client

## Improve @Traceable typing #

Improves for python >= 3.10. Should in theory not change anything for
users of 3.8 and 3.9 (at least, things pass in our 3.8 linting here...
Apologies in advance to any mypy acolytes on 3.{8,9} who gain undesired
linting errors after this change)

Uses:
1. ParamSpec (available in 3.10 and onwards)
2. Protocols (already used)

Even though python doesn't naturally support keyword-only concatenation,
we can work around this with protocols and duck typing to communicate
the actual returned type of "the same function signature + a keyword
only langsmith_extra arg"

Python's typing situation makes it hard to make everyone happy, but
hopefully this strikes a better compromise than before (typing kwargs as
Any in the wrapped function; too lenient)


## Cache default run tree client

---------

Co-authored-by: William Fu-Hinthorn <[email protected]>

python/langsmith/env/_git.py

@@ -47,7 +47,7 @@ def get_git_info(remote: str = "origin") -> GitInfo:
             dirty=None,
             tags=None,
             repo_name=None,
-        ) 
+        )
 
     return {
         "remote_url": exec_git(["remote", "get-url", remote]),

python/langsmith/env/_runtime_env.py

@@ -1,4 +1,5 @@
 """Environment information."""
+
 import functools
 import logging
 import os
@@ -77,6 +78,7 @@ def get_runtime_environment() -> dict:
         "py_implementation": platform.python_implementation(),
         "runtime_version": platform.python_version(),
         "langchain_version": get_langchain_environment(),
+        "langchain_core_version": get_langchain_core_version(),
         **shas,
     }
 
@@ -91,6 +93,16 @@ def get_langchain_environment() -> Optional[str]:
         return None
 
 
+@functools.lru_cache(maxsize=1)
+def get_langchain_core_version() -> Optional[str]:
+    try:
+        import langchain_core  # type: ignore
+
+        return langchain_core.__version__
+    except ImportError:
+        return None
+
+
 @functools.lru_cache(maxsize=1)
 def get_docker_version() -> Optional[str]:
     import subprocess
@@ -138,9 +150,9 @@ def get_docker_environment() -> dict:
     compose_command = _get_compose_command()
     return {
         "docker_version": get_docker_version(),
-        "docker_compose_command": " ".join(compose_command)
-        if compose_command is not None
-        else None,
+        "docker_compose_command": (
+            " ".join(compose_command) if compose_command is not None else None
+        ),
         "docker_compose_version": get_docker_compose_version(),
     }
 

python/langsmith/evaluation/_arunner.py

@@ -801,7 +801,7 @@ async def wait(self) -> None:
 
 
 async def _aforward(
-    fn: rh.SupportsLangsmithExtra[Awaitable],
+    fn: rh.SupportsLangsmithExtra[[dict], Awaitable],
     example: schemas.Example,
     experiment_name: str,
     metadata: dict,
@@ -839,7 +839,9 @@ def _get_run(r: run_trees.RunTree) -> None:
     )
 
 
-def _ensure_async_traceable(target: ATARGET_T) -> rh.SupportsLangsmithExtra[Awaitable]:
+def _ensure_async_traceable(
+    target: ATARGET_T,
+) -> rh.SupportsLangsmithExtra[[dict], Awaitable]:
     if not asyncio.iscoroutinefunction(target):
         raise ValueError(
             "Target must be an async function. For sync functions, use evaluate."

python/langsmith/evaluation/_runner.py

@@ -1466,12 +1466,14 @@ def _resolve_data(
     return data
 
 
-def _ensure_traceable(target: TARGET_T) -> rh.SupportsLangsmithExtra:
+def _ensure_traceable(
+    target: TARGET_T | rh.SupportsLangsmithExtra[[dict], dict],
+) -> rh.SupportsLangsmithExtra[[dict], dict]:
     """Ensure the target function is traceable."""
     if not callable(target):
         raise ValueError("Target must be a callable function.")
     if rh.is_traceable_function(target):
-        fn = cast(rh.SupportsLangsmithExtra, target)
+        fn = target
     else:
         fn = rh.traceable(name="Target")(target)
     return fn

python/langsmith/evaluation/evaluator.py

@@ -181,9 +181,8 @@ def __init__(
             self.afunc = run_helpers.ensure_traceable(func)
             self._name = getattr(func, "__name__", "DynamicRunEvaluator")
         else:
-            self.func = cast(
-                run_helpers.SupportsLangsmithExtra[_RUNNABLE_OUTPUT],
-                run_helpers.ensure_traceable(func),
+            self.func = run_helpers.ensure_traceable(
+                cast(Callable[[Run, Optional[Example]], _RUNNABLE_OUTPUT], func)
             )
             self._name = getattr(func, "__name__", "DynamicRunEvaluator")
 
@@ -383,9 +382,14 @@ def __init__(
             self.afunc = run_helpers.ensure_traceable(func)
             self._name = getattr(func, "__name__", "DynamicRunEvaluator")
         else:
-            self.func = cast(
-                run_helpers.SupportsLangsmithExtra[_COMPARISON_OUTPUT],
-                run_helpers.ensure_traceable(func),
+            self.func = run_helpers.ensure_traceable(
+                cast(
+                    Callable[
+                        [Sequence[Run], Optional[Example]],
+                        _COMPARISON_OUTPUT,
+                    ],
+                    func,
+                )
             )
             self._name = getattr(func, "__name__", "DynamicRunEvaluator")