splight-lib 5.7.1__tar.gz → 5.8.0.dev0__tar.gz

{splight_lib-5.7.1 → splight_lib-5.8.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: splight-lib
-Version: 5.7.1
+Version: 5.8.0.dev0
 Summary: Splight Library
 Author: Splight Dev
 Author-email: dev@splight-ae.com

{splight_lib-5.7.1 → splight_lib-5.8.0.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "splight-lib"
-version = "5.7.1"
+version = "5.8.0.dev0"
 description = "Splight Library"
 authors = ["Splight Dev <dev@splight-ae.com>"]
 readme = "README.md"

{splight_lib-5.7.1 → splight_lib-5.8.0.dev0}/splight_lib/client/database/__init__.py

@@ -1,13 +1,7 @@
 from splight_lib.client.database.builder import DatabaseClientBuilder
-from splight_lib.client.database.local_client import (
-    LOCAL_DB_FILE,
-    LocalDatabaseClient,
-)
 from splight_lib.client.database.remote_client import RemoteDatabaseClient
 
 __all__ = [
-    LocalDatabaseClient,
     DatabaseClientBuilder,
     RemoteDatabaseClient,
-    LOCAL_DB_FILE,
 ]

splight_lib-5.8.0.dev0/splight_lib/client/database/builder.py

@@ -0,0 +1,11 @@
+from typing import Any, Dict
+
+from splight_lib.client.database.abstract import AbstractDatabaseClient
+from splight_lib.client.database.remote_client import RemoteDatabaseClient
+
+
+class DatabaseClientBuilder:
+    @staticmethod
+    def build(parameters: Dict[str, Any] = {}) -> AbstractDatabaseClient:
+        db_client = RemoteDatabaseClient(**parameters)
+        return db_client

{splight_lib-5.7.1 → splight_lib-5.8.0.dev0}/splight_lib/client/database/classmap.py

@@ -20,8 +20,10 @@ MODEL_NAME_MAP = {
     "routineobject": f"{ENGINE_PREFIX}/component/routines/",
     "secret": f"{ENGINE_PREFIX}/secrets/",
     "setpoint": f"{ENGINE_PREFIX}/setpoints/",
+    "solution": f"{ENGINE_PREFIX}/solution/solutions/",
     "tab": f"{ENGINE_PREFIX}/dashboard/tabs/",
     "hubsolution": f"{HUB_PREFIX}/solution/solutions/",
+    "hubsolutionversion": f"{HUB_PREFIX}/solution/versions/",
 }
 
 CUSTOM_PATHS_MAP = {

{splight_lib-5.7.1 → splight_lib-5.8.0.dev0}/splight_lib/client/database/remote_client.py

@@ -192,7 +192,7 @@ class RemoteDatabaseClient(AbstractDatabaseClient, AbstractRemoteClient):
         self,
         resource_name: str,
         instance: Dict,
-        decrypt: bool = True,
+        type_: Optional[str] = None,
         **kwargs,
     ) -> NamedTemporaryFile:
         """Returns the number of resources in the database for a given model
@@ -211,12 +211,13 @@ class RemoteDatabaseClient(AbstractDatabaseClient, AbstractRemoteClient):
         ------
         InvalidModelName thrown when the model name is not correct.
         """
-        if resource_name.lower() != "file":
+        if resource_name.lower() not in ["file", "hubsolutionversion"]:
             raise InvalidModel("Only files can be downloaded.")
         api_path = self._get_api_path(resource_name)
         resource_id = instance.get("id")
         url = self._base_url / api_path / f"{resource_id}/download_url/"
-        response = self._restclient.get(url)
+        params = {"type": type_} if type_ else {}
+        response = self._restclient.get(url, params=params)
         if response.is_error:
             raise RequestError(response.status_code, response.text)
         download_url = response.json().get("url")
@@ -354,7 +355,33 @@ class RemoteDatabaseClient(AbstractDatabaseClient, AbstractRemoteClient):
                 upload_url,
                 files=file,
             )
-            if response.is_error:
+            if response.ok:
+                raise RequestError(response.status_code, response.text)
+        logger.debug(
+            "File uploaded succesfully %s.", resource_id, tags=LogTags.DATABASE
+        )
+
+    def upload(
+        self,
+        resource_name: str,
+        instance: Dict,
+        file_path: str,
+        type_: Optional[str] = None,
+    ):
+        api_path = self._get_api_path(resource_name)
+        resource_id = instance.get("id")
+        params = {"type": type_} if type_ else {}
+        url = self._base_url / api_path / f"{resource_id}/upload_url/"
+        response = self._restclient.get(url, params=params)
+        if response.is_error:
+            raise RequestError(response.status_code, response.text)
+        upload_url = response.json().get("url")
+        with open(file_path, "rb") as fid:
+            response = requests.put(
+                upload_url,
+                data=fid,
+            )
+            if not response.ok:
                 raise RequestError(response.status_code, response.text)
         logger.debug(
             "File uploaded succesfully %s.", resource_id, tags=LogTags.DATABASE

{splight_lib-5.7.1 → splight_lib-5.8.0.dev0}/splight_lib/client/datalake/__init__.py

@@ -1,5 +1,4 @@
 from splight_lib.client.datalake.builder import DatalakeClientBuilder
-from splight_lib.client.datalake.local_client import LocalDatalakeClient
 from splight_lib.client.datalake.remote_client import (
     BufferedAsyncRemoteDatalakeClient,
     BufferedSyncRemoteDataClient,
@@ -11,5 +10,4 @@ __all__ = [
     SyncRemoteDatalakeClient,
     BufferedAsyncRemoteDatalakeClient,
     BufferedSyncRemoteDataClient,
-    LocalDatalakeClient,
 ]

{splight_lib-5.7.1 → splight_lib-5.8.0.dev0}/splight_lib/client/datalake/builder.py

@@ -1,7 +1,6 @@
 from typing import Any, Dict
 
 from splight_lib.client.datalake.abstract import AbstractDatalakeClient
-from splight_lib.client.datalake.local_client import LocalDatalakeClient
 from splight_lib.client.datalake.remote_client import (
     BufferedAsyncRemoteDatalakeClient,
     BufferedSyncRemoteDataClient,
@@ -13,7 +12,6 @@ DL_CLIENT_TYPE_MAP = {
     DatalakeClientType.BUFFERED_ASYNC: BufferedAsyncRemoteDatalakeClient,
     DatalakeClientType.BUFFERED_SYNC: BufferedSyncRemoteDataClient,
     DatalakeClientType.SYNC: SyncRemoteDatalakeClient,
-    DatalakeClientType.LOCAL: LocalDatalakeClient,
 }
 
 

{splight_lib-5.7.1 → splight_lib-5.8.0.dev0}/splight_lib/models/__init__.py

@@ -24,6 +24,7 @@ from splight_lib.models.hub_solution import HubSolution
 from splight_lib.models.metadata import Metadata
 from splight_lib.models.native import Boolean, Number, String
 from splight_lib.models.secret import Secret
+from splight_lib.models.solution import Solution
 
 __all__ = [
     AdvancedFilter,
@@ -51,6 +52,7 @@ __all__ = [
     RoutineEvaluation,
     String,
     Secret,
+    Solution,
     RoutineObject,
     RoutineObjectInstance,
     Tab,

{splight_lib-5.7.1 → splight_lib-5.8.0.dev0}/splight_lib/models/base.py

@@ -1,10 +1,12 @@
 import json
 from datetime import datetime, timezone
+from enum import auto
 from pathlib import Path
 from typing import ClassVar, Dict, List, Optional, TypeVar
 
 import pandas as pd
 from pydantic import BaseModel, ConfigDict, Field, PrivateAttr
+from strenum import LowercaseStrEnum
 
 from splight_lib.client.database import DatabaseClientBuilder
 from splight_lib.client.database.abstract import AbstractDatabaseClient
@@ -23,6 +25,11 @@ def datalake_model_serializer(data: Dict, default=str, **dumps_kwargs):
 FilePath = TypeVar("FilePath", str, Path)
 
 
+class PrivacyPolicy(LowercaseStrEnum):
+    PUBLIC = auto()
+    PRIVATE = auto()
+
+
 class SplightDatabaseBaseModel(BaseModel):
     _db_client: AbstractDatabaseClient = PrivateAttr()
 
@@ -41,8 +48,7 @@ class SplightDatabaseBaseModel(BaseModel):
             self.model_dump(exclude_none=True, mode="json"),
             files=files_dict,
         )
-        for field in self.model_fields:
-            setattr(self, field, saved.get(field))
+        return self.model_validate(saved)
 
     def delete(self):
         self._db_client.delete(
@@ -67,9 +73,7 @@ class SplightDatabaseBaseModel(BaseModel):
     @staticmethod
     def __get_database_client() -> AbstractDatabaseClient:
         db_client = DatabaseClientBuilder.build(
-            local=settings.LOCAL_ENVIRONMENT,
             parameters={
-                "path": settings.CURRENT_DIR,
                 "base_url": settings.SPLIGHT_PLATFORM_API_HOST,
                 "access_id": settings.SPLIGHT_ACCESS_ID,
                 "secret_key": settings.SPLIGHT_SECRET_KEY,
@@ -182,7 +186,6 @@ class SplightDatalakeBaseModel(BaseModel):
         db_client = DatalakeClientBuilder.build(
             dl_client_type=settings.DL_CLIENT_TYPE,
             parameters={
-                "path": settings.CURRENT_DIR,
                 "base_url": settings.SPLIGHT_PLATFORM_API_HOST,
                 "access_id": settings.SPLIGHT_ACCESS_ID,
                 "secret_key": settings.SPLIGHT_SECRET_KEY,

splight_lib-5.8.0.dev0/splight_lib/models/exceptions.py

@@ -0,0 +1,66 @@
+class MethodNotAllowed(Exception):
+    pass
+
+
+class InvalidObjectInstance(Exception):
+    pass
+
+
+class SecretNotFound(Exception):
+    def __init__(self, name: str):
+        msg = f"Secret {name} not found in database"
+        super().__init__(msg)
+
+
+class SecretDecryptionError(Exception):
+    def __init__(self, name: str):
+        msg = f"Unable to decrypt secret {name}"
+        super().__init__(msg)
+
+
+class InvalidFunctionConfiguration(Exception):
+    pass
+
+
+class MissingFunctionItemExpression(Exception):
+    pass
+
+
+class InvalidAlertConfiguration(Exception):
+    pass
+
+
+class MissingAlertItemExpression(Exception):
+    pass
+
+
+class ForbiddenOperation(Exception):
+    pass
+
+
+class InvalidConfigType(Exception):
+    def __init__(self, name: str, type_: str):
+        msg = (
+            f"Config parameter {name} has an invalid type {type_}. The only "
+            "valid type is 'Asset'"
+        )
+        super().__init__(msg)
+
+
+class InvalidResourceType(Exception):
+    def __init__(self, name: str, type_: str):
+        msg = (
+            f"Resource {name} has an invalid type {type_}. The only "
+            "valid type is 'Asset'"
+        )
+        super().__init__(msg)
+
+
+class MissingAsset(Exception):
+    def __init__(self, name: str):
+        msg = f"Resource {name} is missing the asset value"
+        super().__init__(msg)
+
+
+class InvalidArgument(Exception):
+    pass

{splight_lib-5.7.1 → splight_lib-5.8.0.dev0}/splight_lib/models/hub.py

@@ -64,16 +64,10 @@ class HubComponent(BaseModel):
     )
     privacy_policy: Optional[str] = None
     component_type: ComponentType = ComponentType.CONNECTOR
-    tenant: Optional[str] = None
     readme: Optional[str] = None
-    picture: Optional[str] = None
     file: Optional[str] = None
     verification: Optional[HubComponentVerificationEnum] = None
-    created_at: Optional[str] = None
-    last_modified: Optional[str] = None
     tags: List[str] = []
-    min_component_capacity: Optional[str] = None
-    usage_count: int = 0
 
     custom_types: List[CustomType] = []
     input: List[InputParameter] = []
@@ -197,6 +191,7 @@ class HubComponent(BaseModel):
         spec.setdefault("component_type", ComponentType.CONNECTOR.value)
         data_cls = cls.model_validate(spec)
 
+        # TODO: Check if this is needed
         data = data_cls.model_dump(exclude_none=True)
 
         to_json = [

splight_lib-5.8.0.dev0/splight_lib/models/hub_solution.py

@@ -0,0 +1,107 @@
+import os
+from glob import glob
+from tempfile import NamedTemporaryFile
+from typing import List, Literal, Optional
+
+import py7zr
+from pydantic import Field
+
+from splight_lib.constants import DESCRIPTION_MAX_LENGTH
+from splight_lib.models.base import (
+    FilePath,
+    PrivacyPolicy,
+    SplightDatabaseBaseModel,
+)
+from splight_lib.models.component import InputParameter
+from splight_lib.utils.hub import (
+    COMPRESSION_TYPE,
+    README_FILE_1,
+    get_ignore_pathspec,
+    get_spec,
+)
+
+
+class InputAsset(InputParameter):
+    type: Literal["Asset"] = "Asset"
+    kind: str
+
+
+class HubSolution(SplightDatabaseBaseModel):
+    id: Optional[str] = None
+    name: str
+    version: str
+    description: Optional[str] = Field(
+        default=None, max_length=DESCRIPTION_MAX_LENGTH
+    )
+    tags: Optional[List[str]] = Field(default=[])
+    privacy_policy: PrivacyPolicy = PrivacyPolicy.PUBLIC
+
+    config: List[InputParameter] = []
+    resources: List[InputAsset] = []
+
+    @classmethod
+    def upload(cls, path: FilePath):
+        db_client = cls._SplightDatabaseBaseModel__get_database_client()
+        spec = get_spec(path)
+        name = spec.get("name")
+        version = spec.get("version")
+
+        raw_hub_solution = db_client.get(
+            resource_name=cls.__name__,
+            filters={"name": name, "version": version},
+        )
+        solution = cls.model_validate(spec)
+        if raw_hub_solution:
+            old_hub_solution = cls.model_validate(raw_hub_solution[0])
+            solution.id = old_hub_solution.id
+
+        solution.save()
+
+        file_name = f"{name}-{version}.{COMPRESSION_TYPE}"
+        ignore_pathspec = get_ignore_pathspec(path)
+        versioned_path = f"{name}-{version}"
+        main_file = os.path.join(path, "__main__.py")
+        readme_path = os.path.join(path, README_FILE_1)
+        if not os.path.exists(main_file):
+            raise FileNotFoundError(f"__main__.py file not found: {main_file}")
+        if not os.path.exists(readme_path):
+            raise FileNotFoundError(f"README.md file not found: {readme_path}")
+        with py7zr.SevenZipFile(file_name, "w") as archive:
+            all_files = glob(f"{path}/**", recursive=True)
+            for filepath in all_files:
+                if ignore_pathspec and ignore_pathspec.match_file(filepath):
+                    continue
+                if os.path.isdir(filepath):
+                    continue
+                rel_filename = os.path.relpath(filepath, path)
+                new_filepath = os.path.join(versioned_path, rel_filename)
+                archive.write(filepath, new_filepath)
+
+        data = solution.model_dump()
+        try:
+            db_client.upload(
+                "hubsolutionversion",
+                instance=data,
+                file_path=file_name,
+                type_="source",
+            )
+            db_client.upload(
+                "hubsolutionversion",
+                instance=data,
+                file_path=readme_path,
+                type_="readme",
+            )
+        except Exception as exc:
+            raise exc
+        finally:
+            if os.path.exists(file_name):
+                os.remove(file_name)
+        return solution
+
+    def download(self) -> NamedTemporaryFile:
+        db_client = self._SplightDatabaseBaseModel__get_database_client()
+        return db_client.download(
+            resource_name="hubsolutionversion",
+            instance=self.model_dump(),
+            type_="source",
+        )

{splight_lib-5.7.1 → splight_lib-5.8.0.dev0}/splight_lib/models/pipeline.py

@@ -14,7 +14,6 @@ def get_datalake_client() -> AbstractDatalakeClient:
     client = DatalakeClientBuilder.build(
         dl_client_type=settings.DL_CLIENT_TYPE,
         parameters={
-            "path": settings.CURRENT_DIR,
             "base_url": settings.SPLIGHT_PLATFORM_API_HOST,
             "access_id": settings.SPLIGHT_ACCESS_ID,
             "secret_key": settings.SPLIGHT_SECRET_KEY,

splight_lib-5.8.0.dev0/splight_lib/models/solution.py

@@ -0,0 +1,161 @@
+from collections import namedtuple
+from typing import NamedTuple, Optional
+
+from pydantic import Field, computed_field
+
+from splight_lib.models.asset import Asset
+from splight_lib.models.base import SplightDatabaseBaseModel
+from splight_lib.models.exceptions import (
+    InvalidArgument,
+    InvalidConfigType,
+    InvalidResourceType,
+    MissingAsset,
+)
+from splight_lib.models.hub_solution import HubSolution
+
+CAST_TO = {
+    "int": int,
+    "float": float,
+    "bool": bool,
+    "str": str,
+}
+
+
+def get_model_class(config: list[dict], name: str) -> NamedTuple:
+    config_class = namedtuple(name, [x.name for x in config])
+    return config_class
+
+
+def load_solution_config(
+    config: list[dict], config_class: NamedTuple
+) -> NamedTuple:
+    config_dict = {}
+    for item in config:
+        if item["type"] not in CAST_TO:
+            raise InvalidConfigType(item["name"], item["type"])
+        if item["multiple"]:
+            value = [CAST_TO[item["type"]](x) for x in item["value"]]
+        else:
+            value = CAST_TO[item["type"]](item["value"])
+        config_dict.update({item["name"]: value})
+    config = config_class(**config_dict)
+    return config
+
+
+def load_solution_resources(
+    resources: list[dict], model_class: NamedTuple
+) -> namedtuple:
+    resources_dict = {}
+    for resource in resources:
+        if type_ := resource["type"] != "Asset":
+            raise InvalidResourceType(resource["name"], type_)
+        if not resource["value"]:
+            raise MissingAsset(resource["name"])
+
+        if resource["multiple"]:
+            value = [Asset.retrieve(x) for x in resource["value"]]
+        else:
+            value = Asset.retrieve(resource["value"])
+        resources_dict.update({resource["name"]: value})
+    resources = model_class(**resources_dict)
+    return resources
+
+
+# class Solution(BaseModel):
+#     id: str
+#     name: str
+#     description: str
+#     hub_solution: HubSolution
+#
+#     @classmethod
+#     def list(cls) -> list[Self]:
+#         return [solution.parse() for solution in RawSolution.list()]
+#
+#     @classmethod
+#     def retrieve(cls, solution_id: str) -> Self:
+#         return RawSolution.retrieve(solution_id).parse()
+
+
+class Solution(SplightDatabaseBaseModel):
+    id: Optional[str] = None
+    name: str
+    description: str
+    hub_solution: HubSolution
+    raw_config: list[dict] = Field(alias="config")
+    raw_resources: list[dict] = Field(alias="resources")
+
+    def model_dump(self, *args, **kwargs):
+        kwargs.update({"by_alias": True})
+        return super().model_dump(*args, **kwargs)
+
+    def model_dump_json(self, *args, **kwargs):
+        kwargs.update({"by_alias": True})
+        return super().model_dump_json(*args, **kwargs)
+
+    @computed_field(alias="parsed_config")
+    @property
+    def config(self) -> NamedTuple:
+        model_class = get_model_class(self.hub_solution.config, "Config")
+        config = load_solution_config(self.raw_config, model_class)
+        return config
+
+    @computed_field(alias="parsed_resources")
+    @property
+    def resources(self) -> NamedTuple:
+        model_class = get_model_class(self.hub_solution.resources, "Resources")
+        resources = load_solution_resources(self.raw_resources, model_class)
+        return resources
+
+    def update_config(self, **kwargs: dict):
+        valid_params = [x["name"] for x in self.raw_config]
+        for key, value in kwargs.items():
+            if key not in valid_params:
+                raise InvalidArgument(
+                    (
+                        f"Got invalid parameter {key}. Valid config parameter "
+                        f"are {valid_params}"
+                    )
+                )
+            for item in self.raw_config:
+                if item["name"] == key:
+                    item["value"] = value
+                    break
+
+    def update_resources(self, **kwargs: dict):
+        valid_params = [x["name"] for x in self.raw_resources]
+        for key, value in kwargs.items():
+            if key not in valid_params:
+                raise InvalidArgument(
+                    (
+                        f"Got invalid parameter {key}. Valid resource "
+                        f"parameter are {valid_params}"
+                    )
+                )
+            for item in self.raw_resources:
+                if item["name"] == key:
+                    item["value"] = value
+                    break
+
+    # def parse(self) -> Solution:
+    #     config = load_solution_config(self.config)
+    #     config_type = NamedTuple(
+    #         "Config", [(x["name"], Any) for x in self.config]
+    #     )
+    #     resources = load_solution_resources(self.resources)
+    #     resouces_type = NamedTuple(
+    #         "Resources", [(x["name"], Any) for x in self.resources]
+    #     )
+    #     model = create_model(
+    #         "Solution",
+    #         __base__=Solution,
+    #         config=(config_type, ...),
+    #         resources=(resouces_type, ...),
+    #     )
+    #     return model(
+    #         id=self.id,
+    #         name=self.name,
+    #         description=self.description,
+    #         hub_solution=self.hub_solution,
+    #         config=config,
+    #         resources=resources,
+    #     )

{splight_lib-5.7.1 → splight_lib-5.8.0.dev0}/splight_lib/settings.py

@@ -1,9 +1,9 @@
 import os
 from enum import Enum
-from typing import Any, Dict, Optional, Tuple, Type
+from typing import Any, Dict, Tuple, Type
 
 import yaml
-from pydantic import ConfigDict, model_validator
+from pydantic import ConfigDict
 from pydantic.fields import FieldInfo
 from pydantic_settings import BaseSettings, PydanticBaseSettingsSource
 
@@ -65,11 +65,6 @@ class SplightSettings(BaseSettings, Singleton):
     SPLIGHT_SECRET_KEY: str = ""
     SPLIGHT_PLATFORM_API_HOST: str = "https://api.splight-ai.com"
 
-    # Parameters for local environment
-    # TODO: to deprecate this and its effects
-    LOCAL_ENVIRONMENT: bool = False
-    CURRENT_DIR: Optional[str] = None
-
     # Parameters for the datalake client
     # Review if is better to use another class for only the DL Client settings
     DL_CLIENT_TYPE: DatalakeClientType = DatalakeClientType.BUFFERED_ASYNC
@@ -78,15 +73,6 @@ class SplightSettings(BaseSettings, Singleton):
 
     model_config = ConfigDict(extra="ignore")
 
-    @model_validator(mode="after")
-    @classmethod
-    def validate_local_environment(
-        cls, instance: "SplightSettings"
-    ) -> "SplightSettings":
-        if instance.LOCAL_ENVIRONMENT:
-            instance.CURRENT_DIR = os.getcwd()
-        return instance
-
     def configure(self, **params: Dict):
         self.model_validate(params)
 

splight_lib-5.8.0.dev0/splight_lib/solution/__init__.py

@@ -0,0 +1,3 @@
+from splight_lib.solution.solution import SolutionLoader
+
+__all__ = [SolutionLoader]

splight_lib-5.8.0.dev0/splight_lib/solution/exceptions.py

@@ -0,0 +1,8 @@
+class MissingInstanceEnvVar(Exception):
+    def __init__(self, env_var: str):
+        super().__init__(f"Missing environment variable: {env_var}")
+
+
+class MissingInstanceId(Exception):
+    def __init__(self):
+        super().__init__("Missing instance id")

splight_lib-5.8.0.dev0/splight_lib/solution/solution.py

@@ -0,0 +1,23 @@
+import json
+import os
+
+from splight_lib.models import Solution
+from splight_lib.solution.exceptions import (
+    MissingInstanceEnvVar,
+    MissingInstanceId,
+)
+
+ENV_VAR = "INSTANCE_AS_STR"
+
+
+class SolutionLoader:
+    @classmethod
+    def from_env(cls) -> Solution:
+        if not (str_instance := os.environ.get(ENV_VAR)):
+            raise MissingInstanceEnvVar(ENV_VAR)
+        str_instance = os.environ.get("INSTANCE_AS_STR", "")
+        instance = json.loads(str_instance)
+        if not (instance_id := instance.get("id")):
+            raise MissingInstanceId()
+        solution = Solution.retrieve(instance_id)
+        return solution