truefoundry 0.2.10__py3-none-any.whl → 0.3.0rc1__py3-none-any.whl

truefoundry/deploy/function_service/remote/context.py

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

truefoundry/deploy/function_service/remote/method.py

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,144 @@
+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 arbitary 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

@@ -0,0 +1,137 @@
+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

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1,53 @@
+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/deploy/io/output_callback.py

@@ -0,0 +1,23 @@
+class OutputCallBack:
+    def print_header(self, line):
+        print(line)
+
+    def _print_separator(self):
+        print("-" * 80)
+
+    def print_line(self, line):
+        print(line)
+
+    def print_lines_in_panel(self, lines, header=None):
+        self.print_header(header)
+        self._print_separator()
+        for line in lines:
+            self.print_line(line)
+        self._print_separator()
+
+    def print_code_in_panel(self, lines, header=None, lang="python"):
+        self.print_lines_in_panel(lines, header)
+
+    def print(self, line):
+        # just an alias
+        self.print_line(line)

truefoundry/deploy/io/rich_output_callback.py

@@ -0,0 +1,27 @@
+from rich.console import Console
+from rich.highlighter import ReprHighlighter
+from rich.panel import Panel
+from rich.text import Text
+
+from truefoundry.deploy.io.output_callback import OutputCallBack
+
+
+def _text(line):
+    return Text.from_ansi(str(line)) if "\x1b" in line else str(line)
+
+
+class RichOutputCallBack(OutputCallBack):
+    console = Console(soft_wrap=True)
+    highlighter = ReprHighlighter()
+
+    def print_header(self, line):
+        self.console.rule(_text(line), style="cyan")
+
+    def print_line(self, line):
+        self.console.print(_text(line))
+
+    def print_lines_in_panel(self, lines, header=None):
+        self.console.print(Panel(self.highlighter("\n".join(lines)), title=header))
+
+    def print_code_in_panel(self, lines, header=None, lang="python"):
+        self.print_lines_in_panel(lines, header)

truefoundry/deploy/json_util.py

@@ -0,0 +1,7 @@
+import datetime
+
+
+def json_default_encoder(o):
+    if isinstance(o, datetime.datetime):
+        return o.isoformat()
+    raise TypeError(f"Cannot json encode {type(o)}: {o}")

truefoundry/deploy/lib/auth/auth_service_client.py

@@ -0,0 +1,81 @@
+import time
+
+import requests
+
+from truefoundry.deploy.lib.clients.utils import poll_for_function, request_handling
+from truefoundry.deploy.lib.const import VERSION_PREFIX
+from truefoundry.deploy.lib.exceptions import BadRequestException
+from truefoundry.deploy.lib.model.entity import DeviceCode, Token
+from truefoundry.logger import logger
+
+
+class AuthServiceClient:
+    def __init__(self, base_url):
+        from truefoundry.deploy.lib.clients.servicefoundry_client import (
+            ServiceFoundryServiceClient,
+        )
+
+        client = ServiceFoundryServiceClient(init_session=False, base_url=base_url)
+        tenant_info = client.get_tenant_info()
+
+        self._auth_server_url = tenant_info.auth_server_url
+        self._tenant_name = tenant_info.tenant_name
+
+    def refresh_token(self, token: Token, host: str = None) -> Token:
+        host_arg_str = f"--host {host}" if host else "--host HOST"
+        if not token.refresh_token:
+            # TODO: Add a way to propagate error messages without traceback to the output interface side
+            raise Exception(
+                f"Unable to resume login session. Please log in again using `tfy login {host_arg_str} --relogin`"
+            )
+        url = f"{self._auth_server_url}/api/{VERSION_PREFIX}/oauth/token/refresh"
+        data = {
+            "tenantName": token.tenant_name,
+            "refreshToken": token.refresh_token,
+        }
+        res = requests.post(url, data=data)
+        try:
+            res = request_handling(res)
+            return Token.parse_obj(res)
+        except BadRequestException as ex:
+            raise Exception(
+                f"Unable to resume login session. Please log in again using `tfy login {host_arg_str} --relogin`"
+            ) from ex
+
+    def get_device_code(self) -> DeviceCode:
+        url = f"{self._auth_server_url}/api/{VERSION_PREFIX}/oauth/device"
+        data = {"tenantName": self._tenant_name}
+        res = requests.post(url, data=data)
+        res = request_handling(res)
+        return DeviceCode.parse_obj(res)
+
+    def get_token_from_device_code(
+        self, device_code: str, timeout: float = 60
+    ) -> Token:
+        url = f"{self._auth_server_url}/api/{VERSION_PREFIX}/oauth/device/token"
+        data = {
+            "tenantName": self._tenant_name,
+            "deviceCode": device_code,
+        }
+        start_time = time.monotonic()
+        poll_interval_seconds = 1
+
+        for response in poll_for_function(
+            requests.post, poll_after_secs=poll_interval_seconds, url=url, data=data
+        ):
+            if response.status_code == 201:
+                response = response.json()
+                return Token.parse_obj(response)
+            elif response.status_code == 202:
+                logger.debug("User has not authorized yet. Checking again.")
+            else:
+                raise Exception(
+                    "Failed to get token using device code. "
+                    f"status_code {response.status_code},\n {response.text}"
+                )
+            time_elapsed = time.monotonic() - start_time
+            if time_elapsed > timeout:
+                logger.warning("Polled server for %s secs.", int(time_elapsed))
+                break
+
+        raise Exception(f"Did not get authorized within {timeout} seconds.")