truefoundry 0.5.0rc7__py3-none-any.whl → 0.5.1__py3-none-any.whl

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