splight-lib 2.3.19__tar.gz → 3.0.0.dev0__tar.gz

{splight-lib-2.3.19/splight_lib.egg-info → splight-lib-3.0.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: splight-lib
-Version: 2.3.19
+Version: 3.0.0.dev0
 Summary: Library for public use. Splight
 Home-page: UNKNOWN
 Author: Splight

{splight-lib-2.3.19 → splight-lib-3.0.0.dev0}/setup.py

@@ -14,7 +14,7 @@ test_requires = [
 
 setup(
     name="splight-lib",
-    version="2.3.19",
+    version="3.0.0dev0",
     author="Splight",
     author_email="factory@splight-ae.com",
     packages=find_packages(),

splight-lib-2.3.19/splight_abstract/client/abstract.py → splight-lib-3.0.0.dev0/splight_lib/abstract/client.py

@@ -1,54 +1,25 @@
 from abc import ABC
 from collections import UserList
-from functools import wraps
-from typing import Callable, List, Type
-
-from pydantic import BaseModel
-
-from .filter import FilterMixin
-from .hooks import HooksMixin
 
 
 class empty:
     pass
 
 
-def validate_client_resource_type(func: Callable) -> Callable:
-    @wraps(func)
-    def wrapper(self, resource_type: Type, *args, **kwargs):
-        if resource_type not in self.valid_classes:
-            raise NotImplementedError(
-                f"Not a valid resource_type: {resource_type.__name__}"
-            )
-        return func(self, resource_type, *args, **kwargs)
-
-    return wrapper
-
-
-def validate_client_instance_type(func: Callable) -> Callable:
-    @wraps(func)
-    def wrapper(self, instance: BaseModel, *args, **kwargs):
-        if type(instance) not in self.valid_classes:
-            raise NotImplementedError(
-                f"Not a valid instance type: {type(instance).__name__}"
-            )
-        return func(self, instance, *args, **kwargs)
-
-    return wrapper
-
-
-class AbstractClient(ABC, HooksMixin, FilterMixin):
-    valid_classes: List[Type] = []
+class AbstractClient(ABC):
+    pass
 
-    def __init__(self, namespace: str = "default", *args, **kwargs):
-        self.namespace = namespace.lower().replace("_", "")
 
-    def _validated_kwargs(self, resource_type: Type, **kwargs):
-        """
-        Validate the given kwargs.
-        """
-        class_fields = list(resource_type.__fields__.keys())
-        return super()._validated_kwargs(class_fields, **kwargs)
+class AbstractRemoteClient(AbstractClient):
+    def _parse_params(self, **kwargs):
+        params = {}
+        for key, value in kwargs.items():
+            if value is None:
+                continue
+            params[key] = value
+            if isinstance(value, list):
+                params[key] = ",".join(value)
+        return params
 
 
 class QuerySet(UserList):

{splight-lib-2.3.19/splight_abstract → splight-lib-3.0.0.dev0/splight_lib/client}/communication/abstract.py

@@ -1,16 +1,9 @@
 from abc import abstractmethod, abstractproperty
-from enum import Enum
 from typing import Callable, Dict
 
-from splight_abstract.client import AbstractClient
-from splight_models import CommunicationContext, CommunicationEvent
-
-
-class CommunicationClientStatus(str, Enum):
-    STARTING = "starting"
-    READY = "ready"
-    FAILED = "failed"
-    ERROR = "error"
+from splight_lib.abstract.client import AbstractClient
+from splight_lib.models.communication import CommunicationContext
+from splight_lib.models.event import CommunicationEvent
 
 
 class AbstractCommunicationClient(AbstractClient):

{splight-lib-2.3.19 → splight-lib-3.0.0.dev0}/splight_lib/client/communication/classmap.py

@@ -1,4 +1,5 @@
-from splight_models import CommunicationContext, CommunicationEvent
+from splight_lib.models.communication import CommunicationContext
+from splight_lib.models.event import CommunicationEvent
 
 CLASSMAP = {
     CommunicationContext: "v2/engine/communication/context/",

splight-lib-3.0.0.dev0/splight_lib/client/communication/local_client.py

@@ -0,0 +1,7 @@
+from splight_lib.client.communication.abstract import (
+    AbstractCommunicationClient,
+)
+
+
+class LocalCommunicationClient(AbstractCommunicationClient):
+    pass

{splight-lib-2.3.19 → splight-lib-3.0.0.dev0}/splight_lib/client/communication/remote_client.py

@@ -5,35 +5,36 @@ import pysher
 import requests
 from furl import furl
 from retry import retry
-from splight_abstract.communication import (
+from splight_lib.auth import SplightAuthToken
+from splight_lib.client.communication.abstract import (
     AbstractCommunicationClient,
-    ClientNotReady,
 )
-from splight_lib.auth import SplightAuthToken
 from splight_lib.client.communication.classmap import CLASSMAP
-from splight_lib.client.settings import settings_remote as settings
+from splight_lib.client.communication.exceptions import ClientNotReady
 from splight_lib.logging._internal import LogTags, get_splight_logger
-from splight_models.communication import (
+from splight_lib.models.communication import (
     CommunicationClientStatus,
     CommunicationContext,
-    CommunicationEvent,
 )
+from splight_lib.models.event import CommunicationEvent
 
 logger = get_splight_logger()
 
 
 class CommunicationFactory:
-    def __init__(self, model):
+    def __init__(self, model, base_url, access_id: str, secret_key: str):
         self._model = model
+        self._base_url = furl(base_url)
+        self._access_id = access_id
+        self._secret_key = secret_key
 
     def get_url(self):
-        base_url = furl(settings.SPLIGHT_PLATFORM_API_HOST)
-        return base_url / CLASSMAP.get(self._model)
+        return self._base_url / CLASSMAP.get(self._model)
 
     def get_headers(self):
         auth_token = SplightAuthToken(
-            access_key=settings.SPLIGHT_ACCESS_ID,
-            secret_key=settings.SPLIGHT_SECRET_KEY,
+            access_key=self._access_id,
+            secret_key=self._secret_key,
         )
         return auth_token.header
 
@@ -58,8 +59,19 @@ class CommunicationFactory:
 
 
 class RemoteCommunicationClient(AbstractCommunicationClient):
-    def __init__(self, daemon: bool = True, *args, **kwargs):
+    def __init__(
+        self,
+        url: str,
+        access_id: str,
+        secret_key: str,
+        daemon: bool = True,
+        *args,
+        **kwargs,
+    ):
         super().__init__(*args, **kwargs)
+        self._base_url = url
+        self._access_id = access_id
+        self._secret_key = secret_key
         self._status = CommunicationClientStatus.STOPPED
         self._channel_bindings = []
         self._client, self._context = None, None
@@ -105,7 +117,12 @@ class RemoteCommunicationClient(AbstractCommunicationClient):
     @retry(Exception, tries=3, delay=2, jitter=1)
     def __load_context(self):
         params = {"instance_id": self.instance_id}
-        self._context = CommunicationFactory(CommunicationContext).get(params)
+        self._context = CommunicationFactory(
+            CommunicationContext,
+            base_url=self._base_url,
+            access_id=self._access_id,
+            secret_key=self._secret_key,
+        ).get(params)
 
     @retry(Exception, tries=3, delay=2, jitter=1)
     def __load_client(self):
@@ -162,9 +179,12 @@ class RemoteCommunicationClient(AbstractCommunicationClient):
         raise NotImplementedError
 
     def trigger(self, event: CommunicationEvent):
-        return CommunicationFactory(CommunicationEvent).create(
-            data=event.dict()
-        )
+        return CommunicationFactory(
+            CommunicationEvent,
+            base_url=self._base_url,
+            access_id=self._access_id,
+            secret_key=self._secret_key,
+        ).create(data=event.dict())
 
     def authenticate(
         self, channel_name: str, socket_id: str, custom_data: Dict = None

{splight-lib-2.3.19 → splight-lib-3.0.0.dev0}/splight_lib/client/database/__init__.py

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

splight-lib-3.0.0.dev0/splight_lib/client/database/abstract.py

@@ -0,0 +1,28 @@
+from abc import abstractmethod
+from tempfile import NamedTemporaryFile
+from typing import Dict, List, Union
+
+from splight_lib.abstract.client import AbstractClient, QuerySet
+
+
+class AbstractDatabaseClient(AbstractClient):
+    @abstractmethod
+    def save(self, resource_name: str, instance: Dict) -> Dict:
+        pass
+
+    @abstractmethod
+    def _get(
+        self, resource_name: str, first: bool = False, **kwargs
+    ) -> Union[Dict, List[Dict]]:
+        pass
+
+    def get(self, resource_name: str, *args, **kwargs) -> QuerySet:
+        return QuerySet(self, resource_name, *args, **kwargs)
+
+    @abstractmethod
+    def delete(self, resource_name: str, id: str) -> None:
+        pass
+
+    @abstractmethod
+    def download(self, instance: Dict) -> NamedTemporaryFile:
+        pass

splight-lib-3.0.0.dev0/splight_lib/client/database/builder.py

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

splight-lib-3.0.0.dev0/splight_lib/client/database/classmap.py

@@ -0,0 +1,18 @@
+from splight_lib.constants import ENGINE_PREFIX
+
+MODEL_NAME_MAP = {
+    "alert": f"{ENGINE_PREFIX}/alert/alerts/",
+    "asset": f"{ENGINE_PREFIX}/assets/",
+    "attribute": f"{ENGINE_PREFIX}/attributes/",
+    "component": f"{ENGINE_PREFIX}/component/components/",
+    "componentobject": f"{ENGINE_PREFIX}/component/objects/",
+    "file": f"{ENGINE_PREFIX}/files/",
+    "query": f"{ENGINE_PREFIX}/queries/",
+    "secret": f"{ENGINE_PREFIX}/secrets/",
+    "setpoint": f"{ENGINE_PREFIX}/setpoints/",
+}
+
+CUSTOM_PATHS_MAP = {
+    "set-asset-attribute": "{prefix}/assets/{asset}/set-attribute/",
+    "get-asset-attribute": "{prefix}/assets/{asset}/get-attribute/",
+}

splight-lib-3.0.0.dev0/splight_lib/client/database/local_client.py

@@ -0,0 +1,185 @@
+import json
+import os
+from functools import partial
+from tempfile import NamedTemporaryFile
+from typing import Dict, List, Union
+from uuid import uuid4
+
+from splight_lib.client.database.abstract import AbstractDatabaseClient
+from splight_lib.client.exceptions import InstanceNotFound
+from splight_lib.client.filter import value_filter_on_tuple
+from splight_lib.logging._internal import LogTags, get_splight_logger
+
+logger = get_splight_logger()
+
+
+class LocalDatabaseClient(AbstractDatabaseClient):
+    """Database Client implementation for a local database that uses a
+    JSON file.
+    """
+
+    def __init__(self, path: str, *args, **kwargs):
+        super().__init__()
+        self._db_file = os.path.join(path, "splight-db.json")
+
+        if not os.path.exists(self._db_file):
+            self._save_db(self._db_file, {})
+        logger.debug(
+            "Local database client initialized.", tags=LogTags.DATABASE
+        )
+
+    def save(self, resource_name: str, instance: Dict) -> Dict:
+        """Creates or updates a resource depending on the name if
+        it contains the id or not.
+
+        Parameters
+        ----------
+        resource_name: str
+            The name of the resource to be created or updated.
+        instance : Dict
+            A dictionary with resource to be created or updated
+
+        Returns
+        -------
+        Dict with the created or updated resource.
+
+        Raises
+        ------
+        InvalidModelName thrown when the model name is not correct.
+        """
+        logger.debug("Saving instance", tags=LogTags.DATABASE)
+
+        model_name = resource_name.lower()
+        if instance.get("id"):
+            saved_instance = self._update(model_name, instance)
+        else:
+            saved_instance = self._create(model_name, instance)
+        return saved_instance
+
+    def delete(self, resource_name: str, id: str):
+        """Deletes a resource from the database
+
+        Parameters
+        ----------
+        resource_name : str
+            The resource name
+        id : str
+            The resource's id.
+
+        Raises
+        ------
+        InvalidModelName thrown when the model name is not correct.
+        """
+        logger.debug("Deleting instance %s.", id, tags=LogTags.DATABASE)
+        model_name = resource_name.lower()
+        db = self._load_db_file(self._db_file)
+        db_instances = db.get(model_name, {})
+
+        if id not in db_instances:
+            raise InstanceNotFound(model_name, id)
+
+        _ = db_instances.pop(id)
+        self._save_db(self._db_file, db)
+
+    def operate(self, resource_name: str, instance: Dict) -> Dict:
+        raise NotImplementedError("Method not allowed for Local Database")
+
+    def _get(
+        self,
+        resource_name: str,
+        first: bool = False,
+        **kwargs,
+    ) -> Union[Dict, List[Dict]]:
+        """Retrieves one or multiple resources. If the parameter id is passed
+        as a kwarg, the instance with that id will be retrieved.
+
+        Parameters
+        ----------
+        resource_name : str
+            The name of the resource.
+        first: bool
+            Whether to retrieve first element or not.
+
+        Returns
+        -------
+        Union[Dict, List[Dict]] list of resource or single resource.
+        """
+        resource_id = kwargs.pop("id", None)
+        model_name = resource_name.lower()
+        if resource_id:
+            result = self._retrieve_single(model_name, resource_id)
+        else:
+            result = self._retrieve_multiple(model_name, first=first, **kwargs)
+        return result
+
+    def _retrieve_single(self, model_name: str, resource_id: str) -> Dict:
+        db = self._load_db_file(self._db_file)
+        db_instances = db.get(model_name, {})
+        if resource_id not in db_instances:
+            raise InstanceNotFound(model_name, resource_id)
+        return db_instances.get(resource_id)
+
+    def _retrieve_multiple(
+        self, model_name: str, first: bool = False, **kwargs
+    ) -> List[Dict]:
+        db = self._load_db_file(self._db_file)
+        db_instances = db.get(model_name, {})
+
+        filters = self._validate_filters(kwargs)
+        filtered = self._filter(db_instances, filters=filters)
+        instances = list(filtered.values())
+        if first:
+            return [instances[0]]
+        return instances
+
+    def download(
+        self, instances: Dict, decrtypt: bool = True, **kwargs
+    ) -> NamedTemporaryFile:
+        raise NotImplementedError("Method not implemented for Local Database")
+
+    def _create(self, resource_name: str, instance: Dict) -> Dict:
+        db = self._load_db_file(self._db_file)
+        db_instances = db.get(resource_name, {})
+        instance["id"] = str(uuid4())
+        db_instances.update({instance["id"]: instance})
+        db[resource_name] = db_instances
+        self._save_db(self._db_file, db)
+        return instance
+
+    def _update(self, resource_name: str, instance: Dict) -> Dict:
+        db = self._load_db_file(self._db_file)
+        db_instances = db.get(resource_name, {})
+
+        if instance["id"] not in db_instances:
+            raise InstanceNotFound(resource_name, instance["id"])
+        db_instances[instance["id"]] = instance
+        self._save_db(self._db_file, db)
+        return instance
+
+    def _filter(
+        self, instances: Dict[str, Dict], filters: Dict
+    ) -> Dict[str, Dict]:
+        filtered = instances
+        for key, value in filters.items():
+            filtered = filter(
+                partial(value_filter_on_tuple, key, value), filtered.items()
+            )
+            filtered = {item[0]: item[1] for item in filtered}
+        return filtered
+
+    def _load_db_file(self, file_path: str) -> Dict:
+        with open(file_path, "r") as fid:
+            data = json.load(fid)
+        return data
+
+    def _save_db(self, file_path: str, db: Dict):
+        with open(file_path, "w") as fid:
+            json.dump(db, fid, indent=2)
+
+    def _validate_filters(self, filters_raw: Dict):
+        invalid_filters = ["ignore_hook"]
+        return {
+            key: value
+            for key, value in filters_raw.items()
+            if key not in invalid_filters
+        }