splight-lib 5.7.2__tar.gz → 5.8.0.dev1__tar.gz

{splight_lib-5.7.2 → splight_lib-5.8.0.dev1}/PKG-INFO

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

{splight_lib-5.7.2 → splight_lib-5.8.0.dev1}/pyproject.toml

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

{splight_lib-5.7.2 → splight_lib-5.8.0.dev1}/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.2 → splight_lib-5.8.0.dev1}/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.2 → splight_lib-5.8.0.dev1}/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.2 → splight_lib-5.8.0.dev1}/splight_lib/models/asset.py

@@ -22,7 +22,7 @@ class AssetRelationship(BaseModel):
     id: str
     name: str
     description: Optional[str] = None
-    related_asset_kind: Optional[str] = None
+    related_asset_kind: Optional[AssetRepr] = None
     asset: AssetRepr
     related_asset: AssetRepr
 

{splight_lib-5.7.2 → splight_lib-5.8.0.dev1}/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(

splight_lib-5.8.0.dev1/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.2 → splight_lib-5.8.0.dev1}/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.dev1/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.8.0.dev1/splight_lib/models/solution.py

@@ -0,0 +1,122 @@
+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(SplightDatabaseBaseModel):
+    id: Optional[str] = None
+    name: str
+    description: Optional[str] = None
+    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

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

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

splight_lib-5.8.0.dev1/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.dev1/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

splight_lib-5.7.2/splight_lib/models/exceptions.py

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

splight_lib-5.7.2/splight_lib/models/hub_solution.py

@@ -1,49 +0,0 @@
-from enum import auto
-from typing import Dict, List, Optional
-
-from pydantic import Field
-from strenum import LowercaseStrEnum
-
-from splight_lib.constants import DESCRIPTION_MAX_LENGTH
-from splight_lib.models.base import FilePath, SplightDatabaseBaseModel
-
-
-class PrivacyPolicy(LowercaseStrEnum):
-    PUBLIC = auto()
-    PRIVATE = auto()
-
-
-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=None)
-    privacy_policy: PrivacyPolicy = PrivacyPolicy.PUBLIC
-
-    main_file: Optional[FilePath] = Field(default=None, exclude=True)
-    variables_file: Optional[FilePath] = Field(default=None, exclude=True)
-    values_file: Optional[FilePath] = Field(default=None, exclude=True)
-    readme_file: Optional[FilePath] = Field(default=None, exclude=True)
-
-    def save(self) -> None:
-        if not all(
-            [
-                self.main_file,
-                self.variables_file,
-                self.values_file,
-                self.readme_file,
-            ]
-        ):
-            raise ValueError("Missing one of the required files")
-        return super().save()
-
-    def _get_model_files_dict(self) -> Optional[Dict]:
-        return {
-            "main_file": self.main_file,
-            "variables_file": self.variables_file,
-            "values_file": self.values_file,
-            "readme_file": self.readme_file,
-        }