truefoundry 0.5.0rc6__py3-none-any.whl → 0.5.1rc1__py3-none-any.whl

truefoundry/deploy/function_service/app.py

@@ -1,92 +0,0 @@
-import importlib
-import os
-from threading import Thread
-
-import uvicorn
-from fastapi import FastAPI
-
-from truefoundry.deploy.function_service.remote import QUAL_NAME_TO_URL_MAP
-from truefoundry.deploy.function_service.route import (
-    ClassRoute,
-    FunctionRoute,
-    RouteGroups,
-)
-from truefoundry.deploy.function_service.utils import (
-    create_pydantic_model_from_function_signature,
-)
-
-
-def _encapsulate_user_function(function, input_model_name: str):
-    model = create_pydantic_model_from_function_signature(
-        func=function, model_name=input_model_name
-    )
-
-    def func(x: model):
-        return function(**dict(x._iter(to_dict=False)))
-
-    return func
-
-
-def _add_function_route(app: FastAPI, function_route: FunctionRoute, port: int):
-    module = importlib.import_module(function_route.module)
-    function = getattr(module, function_route.function_name)
-
-    app.add_api_route(
-        path=function_route.path,
-        endpoint=_encapsulate_user_function(
-            function, input_model_name=function_route.qual_name
-        ),
-        methods=[function_route.http_method],
-    )
-    QUAL_NAME_TO_URL_MAP[function_route.qual_name] = (
-        f"http://localhost:{port}{function_route.path}"
-    )
-
-
-def _add_class_route(app: FastAPI, class_route: ClassRoute, port: int):
-    module = importlib.import_module(class_route.module)
-    class_factory = getattr(module, class_route.class_name)
-    instance = class_factory(**class_route.init_kwargs)
-
-    for route in class_route.routes:
-        function = getattr(instance, route.function_name)
-        app.add_api_route(
-            path=route.path,
-            endpoint=_encapsulate_user_function(function, route.qual_name),
-            methods=[route.http_method],
-        )
-
-        QUAL_NAME_TO_URL_MAP[route.qual_name] = f"http://localhost:{port}{route.path}"
-
-
-def build_app(route_groups: RouteGroups, port: int) -> FastAPI:
-    _root_path = os.getenv("TFY_SERVICE_ROOT_PATH")
-    app_kwargs = {"root_path": _root_path} if _root_path else {}
-    app = FastAPI(docs_url="/", **app_kwargs)
-    app.add_api_route(path="/ping", endpoint=lambda: "pong")
-
-    for route in route_groups.functions:
-        _add_function_route(app=app, function_route=route, port=port)
-
-    for class_route in route_groups.classes.values():
-        _add_class_route(app=app, class_route=class_route, port=port)
-
-    # print(json.dumps(QUAL_NAME_TO_URL_MAP, indent=2))
-    return app
-
-
-def build_and_run_app(route_groups: RouteGroups, port: int):
-    app = build_app(route_groups=route_groups, port=port)
-    uvicorn.run(app, port=port, host="0.0.0.0")
-
-
-def build_and_run_app_in_background_thread(
-    route_groups: RouteGroups, port: int
-) -> Thread:
-    thread = Thread(
-        target=build_and_run_app,
-        kwargs={"route_groups": route_groups, "port": port},
-        daemon=True,
-    )
-    thread.start()
-    return thread

truefoundry/deploy/function_service/build.py

@@ -1,45 +0,0 @@
-import json
-import sys
-from typing import List, Optional
-
-from truefoundry.deploy.function_service.route import RouteGroups
-from truefoundry.deploy.v2.lib.patched_models import PythonBuild
-from truefoundry.logger import logger
-from truefoundry.pydantic_v1 import BaseModel, constr
-from truefoundry.version import __version__
-
-
-class BuildConfig(BaseModel):
-    python_version: constr(regex=r"^\d+(\.\d+){1,2}$") = (
-        f"{sys.version_info.major}.{sys.version_info.minor}"
-    )
-    pip_packages: Optional[List[str]]
-    requirements_path: Optional[str] = None
-
-    def __init__(self, **data):
-        pip_packages = data.get("pip_packages", [])
-        # locally version == 0.0.0
-        # pip_packages.append(f"truefoundry=={__version__}")
-
-        if __version__ in ("NA", "0.0.0"):
-            # TODO (chiragjn): Any change to truefoundry.deploy.function_service.__main__ is untestable!
-            #   We need to vendor `truefoundry.deploy.function_service` parts in the local source to be able to test.
-            tfy_version = "<=1.0.0"
-            logger.info("Could not detect truefoundry version. Using %r", tfy_version)
-        else:
-            tfy_version = f"=={__version__}"
-
-        pip_packages.append(f"truefoundry{tfy_version}")
-        data["pip_packages"] = pip_packages
-        super().__init__(**data)
-
-    def to_tfy_python_build_config(
-        self, port: int, route_groups: RouteGroups
-    ) -> PythonBuild:
-        escaped_route_groups_json = json.dumps(route_groups.json())
-        return PythonBuild(
-            python_version=self.python_version,
-            pip_packages=self.pip_packages,
-            requirements_path=self.requirements_path,
-            command=f"python -m truefoundry.deploy.function_service run --port {port} --route-groups-json {escaped_route_groups_json}",
-        )

truefoundry/deploy/function_service/remote/__init__.py

@@ -1,6 +0,0 @@
-from truefoundry.deploy.function_service.remote.context import QUAL_NAME_TO_URL_MAP
-from truefoundry.deploy.function_service.remote.remote import (
-    RemoteClass,
-    RemoteFunction,
-    remote,
-)

truefoundry/deploy/function_service/remote/context.py

@@ -1,3 +0,0 @@
-from typing import Dict
-
-QUAL_NAME_TO_URL_MAP: Dict[str, str] = {}

truefoundry/deploy/function_service/remote/method.py

@@ -1,67 +0,0 @@
-from __future__ import annotations
-
-import abc
-import json
-from typing import TYPE_CHECKING
-
-import requests
-
-from truefoundry.deploy.function_service.remote.context import QUAL_NAME_TO_URL_MAP
-
-if TYPE_CHECKING:
-    from truefoundry.deploy.function_service.remote.remote import Remote
-
-
-class Method(abc.ABC):
-    def __call__(self, *args, **kwargs):
-        if len(args) > 0:
-            raise Exception(
-                "Positional arguments are not supported now.\n"
-                "Please use keyword arguments"
-            )
-        return self.run(**kwargs)
-
-    @abc.abstractmethod
-    def run(self, **kwargs): ...
-
-    @abc.abstractmethod
-    async def run_async(self, **kwargs): ...
-
-
-class LocalMethod(Method):
-    def __init__(self, remote_object: Remote, method):
-        self._remote_object = remote_object
-        self._method_name = method.__name__
-
-    def run(self, **kwargs):
-        return getattr(self._remote_object.instance, self._method_name)(**kwargs)
-
-    async def run_async(self, **kwargs):
-        raise NotImplementedError()
-
-
-class RemoteMethod(Method):
-    def __init__(self, remote_object: Remote, method):
-        self._remote_object = remote_object
-        self._method_name = method.__name__
-        self._qual_name = self._remote_object.get_qual_name(method)
-
-    def check(self) -> bool:
-        return self._qual_name in QUAL_NAME_TO_URL_MAP
-
-    def run(self, **kwargs):
-        url = QUAL_NAME_TO_URL_MAP.get(self._qual_name)
-        r = requests.post(url, json=kwargs)
-        assert r.status_code == 200, r.text
-        return json.loads(r.text)
-
-    async def run_async(self, **kwargs):
-        raise NotImplementedError()
-
-
-def method_factory(*args, **kwargs) -> Method:
-    remote_method = RemoteMethod(*args, **kwargs)
-    if remote_method.check():
-        return remote_method
-
-    return LocalMethod(*args, **kwargs)

truefoundry/deploy/function_service/remote/remote.py

@@ -1,144 +0,0 @@
-import abc
-import inspect
-from typing import Dict, Optional
-
-from truefoundry.deploy.function_service.remote.method import method_factory
-from truefoundry.deploy.function_service.utils import get_qual_name
-
-
-class Remote(abc.ABC):
-    @property
-    @abc.abstractmethod
-    def instance(self): ...
-
-    @abc.abstractmethod
-    def get_qual_name(self, method) -> str: ...
-
-
-class RemoteFunction(Remote):
-    def __init__(self, func, **kwargs):
-        self._func = func
-        self._instance = inspect.getmodule(self._func)
-        self.method = method_factory(remote_object=self, method=self._func)
-
-    def __call__(self, *args, **kwargs):
-        if len(args) > 0:
-            raise Exception(
-                "Positional arguments are not supported now.\n"
-                "Please use keyword arguments"
-            )
-        return self.method.__call__(**kwargs)
-
-    def run(self, **kwargs):
-        return self.method.run(**kwargs)
-
-    async def run_async(self, **kwargs):
-        return await self.method.run_async(**kwargs)
-
-    @property
-    def instance(self):
-        return self._instance
-
-    def get_qual_name(self, method) -> str:
-        return get_qual_name(method)
-
-
-class RemoteClass(Remote):
-    def __init__(
-        self,
-        class_,
-        *,
-        init_kwargs: Optional[Dict] = None,
-        name: Optional[str] = None,
-        **kwargs,
-    ):
-        self._class = class_
-        self._name = name or class_.__name__
-        self._init_kwargs = init_kwargs or {}
-
-        self._instance = None
-
-        ###############
-        # Maybe this is not the right way to model it.
-        # Another approach can be, identify whether the environment is local
-        # or our service. If local, then we can just return the instance of
-        # the user defined class. Else, we return a class which reflects the
-        # methods in the class, but internally doing network call.
-        # But I am sticking with this now because not all the concepts of a python
-        # class right now, will work in both remote and local. Examples, you cannot
-        # access arbitrary attributes, properties etc. I want to keep the behaviour
-        # identical for now.
-        absent = object()
-        methods = inspect.getmembers(class_, predicate=inspect.isfunction)
-        for method_name, method in methods:
-            if method_name.startswith("_"):
-                continue
-            existing_attribute = getattr(self, method_name, absent)
-            if existing_attribute is not absent:
-                raise Exception(
-                    f"Cannot reflect {method_name!r} of class {class_.__name__!r}.\n"
-                    f"{method_name!r} is reserved. Use a different method name"
-                )
-
-            setattr(
-                self,
-                method_name,
-                method_factory(remote_object=self, method=method),
-            )
-        ###############
-
-    def get_qual_name(self, method) -> str:
-        return f"{self.name}:{get_qual_name(method)}"
-
-    @property
-    def instance(self):
-        if self._instance:
-            return self._instance
-        instance = self._class(**self._init_kwargs)
-        self._instance = instance
-        return self._instance
-
-    @property
-    def class_(self):
-        return self._class
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def init_kwargs(self) -> Dict:
-        return self._init_kwargs
-
-
-def remote(func_or_class, **kwargs):
-    if inspect.isfunction(func_or_class):
-        return RemoteFunction(func_or_class, **kwargs)
-    if inspect.isclass(func_or_class):
-        return RemoteClass(func_or_class, **kwargs)
-
-    raise Exception()
-
-
-if __name__ == "__main__":
-
-    def foo(a, b):
-        print(a, b)
-
-    remote(foo)(a=1, b=2)
-
-    class Foo:
-        def __init__(self, a, b):
-            self.a = a
-            self.b = b
-
-        def foo(self):
-            print(self.a, self.b)
-
-    foo_instance = remote(Foo, name="foo", init_kwargs={"a": 1, "b": 2})
-    foo_instance_2 = remote(Foo, name="foo_2", init_kwargs={"a": 3, "b": 2})
-
-    foo_instance.foo()
-    foo_instance_2.foo()
-    foo_instance.foo.run()
-    # foo_instance.foo.async_run()

truefoundry/deploy/function_service/route.py

@@ -1,137 +0,0 @@
-import inspect
-import json
-from typing import Any, Callable, Dict, List
-
-from truefoundry.deploy.function_service.remote import RemoteClass
-from truefoundry.deploy.function_service.utils import (
-    create_pydantic_model_from_function_signature,
-    get_qual_name,
-)
-from truefoundry.logger import logger
-from truefoundry.pydantic_v1 import BaseModel, Field, constr, validator
-
-
-def validate_we_can_create_pydantic_model_of_func_args(func: Callable):
-    qual_name = get_qual_name(func)
-    try:
-        create_pydantic_model_from_function_signature(func, get_qual_name(func))
-    except Exception as ex:
-        raise Exception(
-            f"Unable to create a route for {qual_name!r}.\n"
-            "Please ensure that in the function type signature, you have only used in-built\n"
-            "types like `int`, `float`, `str`, `bool`, `typing.Dict`, `typing.List`, typing.Optional`.\n"
-            "To temporarily resolve this error, you can remove the unsupported type signatures.\n"
-        ) from ex
-
-
-def path_pre_processor(path: str, prefix: str = "") -> str:
-    path = path.strip("/")
-
-    if not path:
-        raise ValueError("path cannot be empty")
-
-    prefix = prefix.strip("/")
-    if not prefix:
-        return f"/{path}"
-
-    return f"/{prefix}/{path}"
-
-
-class Route(BaseModel):
-    function_name: str
-    http_method: str
-    path: constr(regex=r"^[A-Za-z0-9\-_/]+$")
-
-    qual_name: str
-
-
-class FunctionRoute(Route):
-    module: str
-
-    @classmethod
-    def from_func(cls, func: Callable, path: str):
-        validate_we_can_create_pydantic_model_of_func_args(func)
-        return cls(
-            function_name=func.__name__,
-            http_method="POST",
-            path=path_pre_processor(path or func.__name__),
-            qual_name=get_qual_name(func),
-            module=func.__module__,
-        )
-
-
-class ClassRoute(BaseModel):
-    class_name: str
-    init_kwargs: Dict[str, Any] = Field(default_factory=dict)
-    module: str
-
-    routes: List[Route] = Field(default_factory=list)
-
-    @validator("init_kwargs")
-    def init_kwargs_is_json_serializable(cls, v, values):
-        try:
-            json.dumps(v)
-        except Exception as ex:
-            class_name = values.get("class_name")
-            raise ValueError(
-                f"init_kwargs {v!r} of class {class_name!r} is not JSON serializable"
-            ) from ex
-
-        return v
-
-    @classmethod
-    def from_class(cls, remote_class: RemoteClass):
-        routes = []
-        methods = inspect.getmembers(remote_class.class_, predicate=inspect.isfunction)
-
-        for method_name, method in methods:
-            if method_name.startswith("_"):
-                continue
-            validate_we_can_create_pydantic_model_of_func_args(method)
-            route = Route(
-                function_name=method_name,
-                http_method="POST",
-                path=path_pre_processor(prefix=remote_class.name, path=method_name),
-                qual_name=remote_class.get_qual_name(method),
-            )
-            routes.append(route)
-
-        return cls(
-            class_name=remote_class.class_.__name__,
-            init_kwargs=remote_class.init_kwargs,
-            routes=routes,
-            module=remote_class.class_.__module__,
-        )
-
-
-class RouteGroups(BaseModel):
-    functions: List[FunctionRoute] = Field(default_factory=list)
-    classes: Dict[str, ClassRoute] = Field(default_factory=dict)
-
-    def register_function(self, func, path):
-        function_route = FunctionRoute.from_func(func=func, path=path)
-        logger.info(
-            "Function %r from module %r will be deployed on path '%s %s'.",
-            function_route.function_name,
-            function_route.module,
-            function_route.http_method,
-            function_route.path,
-        )
-        self.functions.append(function_route)
-
-    def register_class(self, remote_class: RemoteClass):
-        if remote_class.name in self.classes:
-            raise ValueError(
-                f"name {remote_class.name!r} is already used to register a class"
-            )
-        class_route = ClassRoute.from_class(remote_class)
-        for route in class_route.routes:
-            logger.info(
-                "Method %r from `%s:%s` will be deployed on path '%s %s'.",
-                route.function_name,
-                class_route.class_name,
-                remote_class.name,
-                route.http_method,
-                route.path,
-            )
-        self.classes[remote_class.name] = class_route

truefoundry/deploy/function_service/service.py

@@ -1,113 +0,0 @@
-from threading import Thread
-from typing import Any, Callable, Dict, Optional, Union
-
-import yaml
-
-from truefoundry.deploy.auto_gen.models import Port, Resources
-from truefoundry.deploy.function_service.app import (
-    build_and_run_app_in_background_thread,
-)
-from truefoundry.deploy.function_service.build import BuildConfig
-from truefoundry.deploy.function_service.remote import RemoteClass
-from truefoundry.deploy.function_service.route import RouteGroups
-from truefoundry.deploy.v2.lib.deployable_patched_models import Service
-from truefoundry.deploy.v2.lib.patched_models import Build, LocalSource
-from truefoundry.logger import logger
-
-
-class FunctionService:
-    def __init__(
-        self,
-        name: str,
-        build_config: Optional[BuildConfig] = None,
-        resources: Optional[Resources] = None,
-        replicas: int = 1,
-        port: Union[int, Port] = 8000,
-        env: Optional[Dict[str, str]] = None,
-    ):
-        self._name = name
-        self._build_config = build_config or BuildConfig()
-        self._resources = resources or Resources()
-        self._replicas = replicas
-        if isinstance(port, int):
-            port = Port(port=port, expose=False)
-        if not port.host:
-            logger.warning(
-                "No host is set for the port. This is not an issue if you don't "
-                "want an exposed endpoint or are just testing locally.\n"
-                "However, for actual deployment it is required to pass an "
-                "instance of `truefoundry.deploy.Port` with "
-                "`host` argument defined.\n"
-                "E.g. `FunctionService(name='...', port=Port(port=8000, host='...', path='...'), ...)`"
-            )
-        self._port = port
-        self._env = env or {}
-
-        self._route_groups: RouteGroups = RouteGroups()
-
-    @property
-    def route_groups(self) -> RouteGroups:
-        return self._route_groups
-
-    def __repr__(self):
-        return yaml.dump(
-            {
-                "name": self._name,
-                "build_config": self._build_config.dict(),
-                "resources": self._resources.dict(),
-                "routes": self._route_groups.dict(),
-                "replicas": self._replicas,
-                "port": self._port.dict(),
-                "env": self._env,
-            },
-            indent=2,
-        )
-
-    def register_function(
-        self,
-        func: Callable,
-        *,
-        path: Optional[str] = None,
-    ):
-        self._route_groups.register_function(func=func, path=path)
-
-    def register_class(
-        self,
-        class_,
-        *,
-        init_kwargs: Optional[Dict[str, Any]] = None,
-        name: Optional[str] = None,
-    ):
-        # TODO: I need to rethink this `RemoteClass`.
-        #   I am mixing up multiple responsibilities here.
-        #   For now, I am removing the burden of using `remote` from the user when deploying
-        #   an instance of a class.
-        remote_class = RemoteClass(class_, init_kwargs=init_kwargs, name=name)
-        self._route_groups.register_class(remote_class=remote_class)
-
-    def run(self) -> Thread:
-        return build_and_run_app_in_background_thread(
-            route_groups=self._route_groups, port=self._port.port
-        )
-
-    def get_deployment_definition(self) -> Service:
-        # Keeping this function right now so that later,
-        # the constructor of the application call this function
-        # to get the component spec, if an object of this class
-        # is directly passed as a component
-        tfy_python_build_config = self._build_config.to_tfy_python_build_config(
-            port=self._port.port, route_groups=self._route_groups
-        )
-        service = Service(
-            name=self._name,
-            image=Build(build_source=LocalSource(), build_spec=tfy_python_build_config),
-            resources=self._resources,
-            replicas=self._replicas,
-            ports=[self._port],
-            env=self._env,
-        )
-        return service
-
-    def deploy(self, workspace_fqn: str, wait: bool = True):
-        service = self.get_deployment_definition()
-        service.deploy(workspace_fqn=workspace_fqn, wait=wait)

truefoundry/deploy/function_service/utils.py

@@ -1,53 +0,0 @@
-import inspect
-from typing import Any
-
-from truefoundry.pydantic_v1 import BaseModel
-from truefoundry.pydantic_v1 import create_model as pydantic_create_model
-
-
-def get_qual_name(obj):
-    return f"{obj.__module__}.{obj.__qualname__}"
-
-
-def create_pydantic_model_from_function_signature(func, model_name: str):
-    # https://github.com/pydantic/pydantic/issues/1391
-    (
-        args,
-        _,
-        varkw,
-        defaults,
-        kwonlyargs,
-        kwonlydefaults,
-        annotations,
-    ) = inspect.getfullargspec(func)
-    defaults = defaults or []
-    args = args or []
-    if len(args) > 0 and args[0] == "self":
-        del args[0]
-
-    non_default_args = len(args) - len(defaults)
-    defaults = [
-        ...,
-    ] * non_default_args + list(defaults)
-
-    keyword_only_params = {
-        param: kwonlydefaults.get(param, Any) for param in kwonlyargs
-    }
-    params = {
-        param: (annotations.get(param, Any), default)
-        for param, default in zip(args, defaults)
-    }
-
-    class Config:
-        extra = "allow"
-
-    # Allow extra params if there is a **kwargs parameter in the function signature
-    config = Config if varkw else None
-
-    return pydantic_create_model(
-        model_name,
-        **params,
-        **keyword_only_params,
-        __base__=BaseModel,
-        __config__=config,
-    )

truefoundry/langchain/__init__.py

@@ -1,12 +0,0 @@
-try:
-    import langchain as _
-except Exception as ex:
-    raise Exception(
-        "Failed to import langchain. "
-        "Please install langchain by using `pip install langchain` command"
-    ) from ex
-from truefoundry.langchain.deprecated import TruefoundryLLM, TruefoundryPlaygroundLLM
-from truefoundry.langchain.truefoundry_chat import TrueFoundryChat
-from truefoundry.langchain.truefoundry_embeddings import TrueFoundryEmbeddings
-from truefoundry.langchain.truefoundry_llm import TrueFoundryLLM
-from truefoundry.langchain.utils import ModelParameters