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

truefoundry/deploy/lib/model/entity.py

@@ -0,0 +1,400 @@
+from __future__ import annotations
+
+import datetime
+import time
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+import jwt
+
+from truefoundry.deploy.lib.util import get_application_fqn_from_deployment_fqn
+from truefoundry.pydantic_v1 import BaseModel, Extra, Field, constr, validator
+
+# TODO: switch to Enums for str literals
+# TODO: Need a better approach to keep fields in sync with server
+#       most fields should have a default in case server adds/removes a field
+# TODO: Implement NotImplementedError sections
+UNDEFINED_STRING = "<Undefined>"
+
+
+class Base(BaseModel):
+    class Config:
+        validate_assignment = True
+        use_enum_values = True
+        extra = Extra.allow
+
+    def __repr_args__(self):
+        return [
+            (key, value)
+            for key, value in self.__dict__.items()
+            if key in self.__fields__
+            and self.__fields__[key].field_info.extra.get("repr", True)
+        ]
+
+
+class Entity(Base):
+    createdAt: datetime.datetime = Field(repr=False)
+    updatedAt: datetime.datetime = Field(repr=False)
+    createdBy: str = Field(repr=False)
+
+
+class Workspace(Entity):
+    id: str = Field(repr=False)
+    name: str
+    fqn: str
+    clusterId: str = Field(repr=False)
+
+    def list_row_data(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "fqn": self.fqn,
+            "cluster_fqn": self.clusterId,
+            "created_at": self.createdAt,
+        }
+
+    def get_data(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "fqn": self.fqn,
+            "cluster_fqn": self.clusterId,
+            "created_at": self.createdAt,
+            "updated_at": self.updatedAt,
+            "created_by": self.createdBy,
+        }
+
+
+class WorkspaceResources(BaseModel):
+    cpu_limit: Optional[float]
+    memory_limit: Optional[int]
+    ephemeral_storage_limit: Optional[int]
+
+
+class PortMetadata(BaseModel):
+    port: int
+    # TODO: done because of a bug, needs to reverted to be mandatory
+    host: Optional[str]
+
+
+class DeploymentTransitionStatus(str, Enum):
+    INITIALIZED: str = "INITIALIZED"
+    BUILDING: str = "BUILDING"
+    DEPLOYING: str = "DEPLOYING"
+    BUILD_SUCCESS: str = "BUILD_SUCCESS"
+    DEPLOY_SUCCESS: str = "DEPLOY_SUCCESS"
+    DEPLOY_FAILED: str = "DEPLOY_FAILED"
+    BUILD_FAILED: str = "BUILD_FAILED"
+    CANCELLED: str = "CANCELLED"
+    COMPONENTS_DEPLOYING: str = "COMPONENTS_DEPLOYING"
+    FAILED: str = "FAILED"
+    REUSING_EXISTING_BUILD: str = "REUSING_EXISTING_BUILD"
+    REDEPLOY_STARTED: str = "REDEPLOY_STARTED"
+    PAUSED: str = "PAUSED"
+    ROLLOUT_STARTED: str = "ROLLOUT_STARTED"
+    SET_TRAFFIC: str = "SET_TRAFFIC"
+    DEPLOY_FAILED_WITH_RETRY: str = "DEPLOY_FAILED_WITH_RETRY"
+    WAITING: str = "WAITING"
+
+    _: str = ""
+
+    @classmethod
+    def is_failure_state(cls, state: DeploymentTransitionStatus) -> bool:
+        return state in (cls.DEPLOY_FAILED, cls.BUILD_FAILED, cls.FAILED, cls.CANCELLED)
+
+
+class DeploymentState(BaseModel):
+    isTerminalState: bool
+
+
+class DeploymentStatus(BaseModel):
+    state: DeploymentState
+    status: DeploymentTransitionStatus
+    transition: Optional[DeploymentTransitionStatus]
+
+
+class DeploymentManifest(Base):
+    name: Optional[str] = Field(default=UNDEFINED_STRING)
+    type: str
+
+
+class Deployment(Entity):
+    id: str = Field(repr=False)
+    fqn: str
+    version: int
+    currentStatusId: str = Field(repr=False)
+    applicationId: str = Field(repr=False)
+    manifest: DeploymentManifest = Field(repr=False)
+    failureReason: Optional[str]
+    deploymentStatuses: Optional[List[DeploymentStatus]]
+    metadata: Optional[
+        Union[Dict[str, Any], List[Dict[str, Any]]]
+    ]  # TODO (chiragjn): revisit the type of this field
+    currentStatus: Optional[DeploymentStatus]  # Server was not returning CurrentStatus
+    application_fqn: str
+
+    def __init__(self, **kwargs) -> None:
+        deployment_fqn = kwargs.get("fqn")
+        if not deployment_fqn:
+            raise ValueError("'fqn' field is required")
+        application_fqn = ":".join(deployment_fqn.split(":")[:3])
+        kwargs["application_fqn"] = application_fqn
+        super().__init__(**kwargs)
+
+    @property
+    def application_fqn(self) -> str:
+        return get_application_fqn_from_deployment_fqn(self.fqn)
+
+    def list_row_data(self) -> Dict[str, Any]:
+        return {
+            "fqn": self.fqn,
+            "application_name": self.manifest.name,
+            "version": self.version,
+            "created_at": self.createdAt,
+        }
+
+    def get_data(self) -> Dict[str, Any]:
+        # TODO: Remove this splitting logic
+        cluster_fqn, workspace_name, *_ = self.fqn.split(":")
+        workspace_fqn = ":".join([cluster_fqn, workspace_name])
+        return {
+            "fqn": self.fqn,
+            "application_name": self.manifest.name,
+            "application_type": self.manifest.type,
+            "version": self.version,
+            "workspace_fqn": workspace_fqn,
+            "cluster_fqn": cluster_fqn,
+            "created_at": self.createdAt,
+            "updated_at": self.updatedAt,
+            "created_by": self.createdBy,
+        }
+
+    class Config:
+        extra = Extra.allow
+
+
+class ApplicationWorkspace(Base):
+    name: str
+    fqn: str
+    clusterId: str
+
+
+class Application(Entity):
+    id: str = Field(repr=False)
+    name: str
+    fqn: str
+    tenantName: str
+    workspaceId: str = Field(repr=False)
+    lastVersion: int
+    activeVersion: int
+    workspace: ApplicationWorkspace
+    deployment: Deployment
+    activeDeploymentId: Optional[str] = Field(repr=False)
+    lastDeploymentId: str = Field(repr=False)
+
+    def list_row_data(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "type": self.deployment.manifest.type,
+            "fqn": self.fqn,
+            "active_version": self.activeVersion,
+            "workspace_name": self.workspace.name,
+            "created_at": self.createdAt,
+        }
+
+    def get_data(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "type": self.deployment.manifest.type,
+            "fqn": self.fqn,
+            "active_version": self.activeVersion,
+            "last_version": self.lastVersion,
+            "workspace_fqn": self.workspace.fqn,
+            "cluster_fqn": self.workspace.clusterId,
+            "created_at": self.createdAt,
+            "updated_at": self.updatedAt,
+            "created_by": self.createdBy,
+        }
+
+
+class UserType(Enum):
+    user = "user"
+    serviceaccount = "serviceaccount"
+
+
+class UserInfo(BaseModel):
+    user_id: constr(min_length=1)
+    user_type: UserType = UserType.user
+    email: Optional[str] = None
+    tenant_name: constr(min_length=1) = Field(alias="tenantName")
+
+    class Config:
+        allow_population_by_field_name = True
+        allow_mutation = False
+
+
+class TenantInfo(BaseModel):
+    tenant_name: constr(min_length=1) = Field(alias="tenantName")
+    auth_server_url: str
+
+    class Config:
+        allow_population_by_field_name = True
+        allow_mutation = False
+
+
+class Token(BaseModel):
+    access_token: constr(min_length=1) = Field(alias="accessToken", repr=False)
+    refresh_token: Optional[constr(min_length=1)] = Field(
+        alias="refreshToken", repr=False
+    )
+    decoded_value: Optional[Dict] = Field(exclude=True, repr=False)
+
+    class Config:
+        allow_population_by_field_name = True
+        allow_mutation = False
+
+    @validator("decoded_value", always=True, pre=True)
+    def _decode_jwt(cls, v, values, **kwargs):
+        access_token = values["access_token"]
+        return jwt.decode(
+            access_token,
+            options={
+                "verify_signature": False,
+                "verify_aud": False,
+                "verify_exp": False,
+            },
+        )
+
+    @property
+    def tenant_name(self) -> str:
+        return self.decoded_value["tenantName"]
+
+    def is_going_to_be_expired(self, buffer_in_seconds: int = 120) -> bool:
+        exp = int(self.decoded_value["exp"])
+        return (exp - time.time()) < buffer_in_seconds
+
+    def to_user_info(self) -> UserInfo:
+        return UserInfo(
+            user_id=self.decoded_value["username"],
+            email=self.decoded_value["email"]
+            if "email" in self.decoded_value
+            else None,
+            user_type=UserType(self.decoded_value.get("userType", UserType.user.value)),
+            tenant_name=self.tenant_name,
+        )
+
+
+class CredentialsFileContent(BaseModel):
+    access_token: constr(min_length=1) = Field(repr=False)
+    refresh_token: Optional[constr(min_length=1)] = Field(repr=False)
+    host: constr(min_length=1)
+
+    class Config:
+        allow_mutation = False
+
+    def to_token(self) -> Token:
+        return Token(access_token=self.access_token, refresh_token=self.refresh_token)
+
+
+class DeviceCode(BaseModel):
+    user_code: str = Field(alias="userCode")
+    device_code: str = Field(alias="deviceCode")
+    verification_url: Optional[str] = Field(alias="verificationURI")
+    complete_verification_url: Optional[str] = Field(alias="verificationURIComplete")
+    expires_in_seconds: int = Field(alias="expiresInSeconds", default=60)
+    interval_in_seconds: int = Field(alias="intervalInSeconds", default=1)
+    message: Optional[str] = Field(alias="message")
+
+    class Config:
+        allow_population_by_field_name = True
+        allow_mutation = False
+
+    def get_user_clickable_url(self, auth_host: str) -> str:
+        return f"{auth_host}/authorize/device?userCode={self.user_code}"
+
+
+class PythonSDKConfig(BaseModel):
+    min_version: str = Field(alias="minVersion")
+    truefoundry_cli_min_version: str = Field(alias="truefoundryCliMinVersion")
+    use_sfy_server_auth_apis: Optional[bool] = Field(
+        alias="useSFYServerAuthAPIs", default=False
+    )
+
+    class Config:
+        allow_population_by_field_name = True
+        allow_mutation = False
+
+
+class JobRun(Base):
+    name: str
+    applicationName: str
+    deploymentVersion: int
+    createdAt: int
+    endTime: Optional[int] = None
+    duration: Optional[str] = None
+    command: str
+    totalRetries: Optional[int] = 0
+    status: str
+
+    def list_row_data(self) -> Dict[str, Any]:
+        from truefoundry.deploy.cli.display_util import display_time_passed
+
+        triggered_at = (
+            (datetime.datetime.now().timestamp() * 1000) - self.createdAt
+        ) // 1000
+        triggered_at = f"{display_time_passed(triggered_at)} ago"
+        duration = ""
+        if self.duration:
+            duration = display_time_passed(int(float(self.duration)))
+        return {
+            "name": self.name,
+            "deployment_version": self.deploymentVersion,
+            "status": self.status,
+            "triggered_at": triggered_at,
+            "duration": duration,
+        }
+
+    def get_data(self) -> Dict[str, Any]:
+        from truefoundry.deploy.cli.display_util import display_time_passed
+
+        created_at = datetime.datetime.fromtimestamp(self.createdAt // 1000)
+        end_time = ""
+        if self.endTime:
+            end_time = datetime.datetime.fromtimestamp(self.endTime // 1000)
+        duration = ""
+        if self.duration:
+            duration = display_time_passed(int(float(self.duration)))
+        return {
+            "name": self.name,
+            "application_name": self.applicationName,
+            "deployment_version": self.deploymentVersion,
+            "created_at": created_at,
+            "end_time": end_time,
+            "duration": duration,
+            "command": self.command,
+            "status": self.status,
+        }
+
+
+class TriggerJobResult(Base):
+    message: str = Field(default="Unknown")
+    jobRunName: str = Field(default=None)
+
+
+class DockerRegistryCredentials(Base):
+    fqn: str
+    registryUrl: str
+    username: str
+    password: str
+
+
+class CreateDockerRepositoryResponse(Base):
+    repoName: str
+
+
+class ApplyResult(BaseModel):
+    success: bool
+    message: str
+
+
+class Manifest(Base):
+    type: str
+    name: str

truefoundry/deploy/lib/session.py

@@ -0,0 +1,158 @@
+import os
+from typing import Optional
+
+import rich_click as click
+
+from truefoundry.deploy.io.output_callback import OutputCallBack
+from truefoundry.deploy.lib.auth.auth_service_client import AuthServiceClient
+from truefoundry.deploy.lib.auth.credential_file_manager import CredentialsFileManager
+from truefoundry.deploy.lib.auth.credential_provider import EnvCredentialProvider
+from truefoundry.deploy.lib.clients.servicefoundry_client import (
+    ServiceFoundryServiceClient,
+)
+from truefoundry.deploy.lib.clients.utils import resolve_base_url
+from truefoundry.deploy.lib.const import (
+    API_KEY_ENV_NAME,
+    HOST_ENV_NAME,
+    OLD_SFY_PROFILES_FILEPATH,
+    OLD_SFY_SESSIONS_FILEPATH,
+    RICH_OUTPUT_CALLBACK,
+)
+from truefoundry.deploy.lib.messages import (
+    PROMPT_ALREADY_LOGGED_OUT,
+    PROMPT_LOGOUT_SUCCESSFUL,
+)
+from truefoundry.deploy.lib.model.entity import CredentialsFileContent, Token
+from truefoundry.logger import logger
+
+if OLD_SFY_PROFILES_FILEPATH.exists():
+    logger.warning(
+        "%s file is deprecated. You can delete this file now.",
+        OLD_SFY_PROFILES_FILEPATH,
+    )
+
+
+if OLD_SFY_SESSIONS_FILEPATH.exists():
+    logger.warning(
+        "%s file is deprecated. You can delete this file now.",
+        OLD_SFY_SESSIONS_FILEPATH,
+    )
+
+
+def login(
+    api_key: Optional[str] = None,
+    host: Optional[str] = None,
+    relogin: bool = False,
+    output_hook: OutputCallBack = RICH_OUTPUT_CALLBACK,
+) -> bool:
+    if API_KEY_ENV_NAME in os.environ and HOST_ENV_NAME in os.environ:
+        logger.warning(
+            "Skipping login because environment variables %s and "
+            "%s are set and will be used when running truefoundry. "
+            "If you want to relogin then unset these environment keys.",
+            HOST_ENV_NAME,
+            API_KEY_ENV_NAME,
+        )
+        return False
+
+    if EnvCredentialProvider.can_provide():
+        logger.warning(
+            "TFY_API_KEY env var is already set. "
+            "When running truefoundry, it will use the api key to authorize.\n"
+            "Login will just save the credentials on disk."
+        )
+
+    host = resolve_base_url(host).strip("/")
+
+    with CredentialsFileManager() as cred_file:
+        if not relogin and cred_file.exists():
+            cred_file_content = cred_file.read()
+            if host != cred_file_content.host:
+                if click.confirm(
+                    f"Already logged in to {cred_file_content.host!r}\n"
+                    f"Do you want to relogin to {host!r}?"
+                ):
+                    return login(api_key=api_key, host=host, relogin=True)
+
+            user_info = cred_file_content.to_token().to_user_info()
+            user_name_display_info = user_info.email or user_info.user_type.value
+            output_hook.print_line(
+                f"Already logged in to {cred_file_content.host!r} as "
+                f"{user_info.user_id!r} ({user_name_display_info})\n"
+                "Please use `tfy login --relogin` or `tfy.login(relogin=True)` "
+                "to force relogin"
+            )
+            return False
+
+        if api_key:
+            servicefoundry_client = ServiceFoundryServiceClient(
+                init_session=False, base_url=host
+            )
+            token = _login_with_api_key(
+                api_key=api_key, servicefoundry_client=servicefoundry_client
+            )
+        else:
+            auth_service = AuthServiceClient.from_base_url(base_url=host)
+            # interactive login
+            token = _login_with_device_code(base_url=host, auth_service=auth_service)
+
+        cred_file_content = CredentialsFileContent(
+            access_token=token.access_token,
+            refresh_token=token.refresh_token,
+            host=host,
+        )
+        cred_file.write(cred_file_content)
+
+    user_info = token.to_user_info()
+    user_name_display_info = user_info.email or user_info.user_type.value
+    output_hook.print_line(
+        f"Successfully logged in to {cred_file_content.host!r} as "
+        f"{user_info.user_id!r} ({user_name_display_info})"
+    )
+    return True
+
+
+def logout(
+    output_hook: OutputCallBack = RICH_OUTPUT_CALLBACK,
+) -> None:
+    with CredentialsFileManager() as cred_file:
+        if cred_file.delete():
+            output_hook.print_line(PROMPT_LOGOUT_SUCCESSFUL)
+        else:
+            output_hook.print_line(PROMPT_ALREADY_LOGGED_OUT)
+
+
+def _login_with_api_key(
+    api_key: str, servicefoundry_client: ServiceFoundryServiceClient
+) -> Token:
+    logger.debug("Logging in with api key")
+    return servicefoundry_client.get_token_from_api_key(api_key=api_key)
+
+
+def _login_with_device_code(
+    base_url: str,
+    auth_service: AuthServiceClient,
+    output_hook: OutputCallBack = RICH_OUTPUT_CALLBACK,
+) -> Token:
+    logger.debug("Logging in with device code")
+    device_code = auth_service.get_device_code()
+    auto_open_url = None
+    message = "Please click on the above link if it is not automatically opened in a browser window."
+    if device_code.complete_verification_url:
+        auto_open_url = device_code.complete_verification_url
+    elif device_code.verification_url:
+        if device_code.message:
+            message = device_code.message
+        else:
+            message = f"Please open the following URL in a browser and enter the code {device_code.user_code} when prompted: {device_code.verification_url}"
+    else:
+        auto_open_url = device_code.get_user_clickable_url(auth_host=base_url)
+    if auto_open_url:
+        output_hook.print_line(f"Opening:- {auto_open_url}")
+        click.launch(auto_open_url)
+    output_hook.print_line(message)
+    return auth_service.get_token_from_device_code(
+        device_code=device_code.device_code,
+        timeout=device_code.expires_in_seconds,
+        poll_interval_seconds=device_code.interval_in_seconds,
+    )

truefoundry/deploy/lib/util.py

@@ -0,0 +1,90 @@
+import os
+import re
+from functools import lru_cache, wraps
+from time import monotonic_ns
+from typing import Union
+
+from truefoundry.deploy.lib.const import (
+    SFY_DEBUG_ENV_KEY,
+    SFY_INTERNAL_ENV_KEY,
+    TFY_DEBUG_ENV_KEY,
+    TFY_INTERNAL_ENV_KEY,
+)
+
+
+def is_debug_env_set() -> bool:
+    return (
+        True if os.getenv(TFY_DEBUG_ENV_KEY) or os.getenv(SFY_DEBUG_ENV_KEY) else False
+    )
+
+
+def is_internal_env_set() -> bool:
+    return (
+        True
+        if os.getenv(TFY_INTERNAL_ENV_KEY) or os.getenv(SFY_INTERNAL_ENV_KEY)
+        else False
+    )
+
+
+def get_application_fqn_from_deployment_fqn(deployment_fqn: str) -> str:
+    if not re.search(r":\d+$", deployment_fqn):
+        raise ValueError(
+            "Invalid `deployment_fqn` format. A deployment fqn is supposed to end with a version number"
+        )
+    application_fqn, _ = deployment_fqn.rsplit(":", 1)
+    return application_fqn
+
+
+def get_deployment_fqn_from_application_fqn(
+    application_fqn: str, version: Union[str, int]
+) -> str:
+    return f"{application_fqn}:{version}"
+
+
+def is_notebook():
+    # https://stackoverflow.com/questions/15411967/how-can-i-check-if-code-is-executed-in-the-ipython-notebook
+    try:
+        # noinspection PyUnresolvedReferences
+        shell = get_ipython().__class__
+        if shell.__name__ == "ZMQInteractiveShell":
+            return True  # Jupyter notebook or qtconsole
+        elif shell.__name__ == "TerminalInteractiveShell":
+            return False  # Terminal running IPython
+        elif "google.colab" in str(shell):
+            return True  # google colab notebook
+        else:
+            return False  # Other type (?)
+    except NameError:
+        return False  # Probably standard Python interpreter
+
+
+def find_list_paths(data, parent_key="", sep="."):
+    list_paths = []
+    if isinstance(data, dict):
+        for key, value in data.items():
+            new_key = f"{parent_key}{sep}{key}" if parent_key else key
+            list_paths.extend(find_list_paths(value, new_key, sep))
+    elif isinstance(data, list):
+        list_paths.append(parent_key)
+        for i, value in enumerate(data):
+            new_key = f"{parent_key}[{i}]"
+            list_paths.extend(find_list_paths(value, new_key, sep))
+    return list_paths
+
+
+def timed_lru_cache(seconds: int = 300, maxsize: int = None):
+    def wrapper_cache(func):
+        func = lru_cache(maxsize=maxsize)(func)
+        func.delta = seconds * 10**9
+        func.expiration = monotonic_ns() + func.delta
+
+        @wraps(func)
+        def wrapped_func(*args, **kwargs):
+            if monotonic_ns() >= func.expiration:
+                func.cache_clear()
+                func.expiration = monotonic_ns() + func.delta
+            return func(*args, **kwargs)
+
+        return wrapped_func
+
+    return wrapper_cache