splight-lib 3.0.0.dev1__tar.gz → 3.0.0.dev3__tar.gz

{splight-lib-3.0.0.dev1 → splight-lib-3.0.0.dev3}/PKG-INFO

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

{splight-lib-3.0.0.dev1 → splight-lib-3.0.0.dev3}/setup.py

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

{splight-lib-3.0.0.dev1 → splight-lib-3.0.0.dev3}/splight_lib/client/database/remote_client.py

@@ -215,7 +215,7 @@ class RemoteDatabaseClient(AbstractDatabaseClient, AbstractRemoteClient):
             response = self._list(url, **kwargs)
             yield response
             next_page = (
-                response["next"].split("page=")[1]
+                furl(response["next"]).query.params["page"]
                 if response["next"]
                 else None
             )

{splight-lib-3.0.0.dev1 → splight-lib-3.0.0.dev3}/splight_lib/client/datalake/local_client.py

@@ -50,8 +50,7 @@ class LocalDatalakeClient(AbstractDatalakeClient):
 
     def _raw_get(
         self,
-        resource_name: str,
-        collection: str,
+        resource_type: DLResource,
         limit_: int = 1000,
         skip_: int = 0,
         sort: Union[List, str] = ["timestamp__desc"],
@@ -73,9 +72,10 @@ class LocalDatalakeClient(AbstractDatalakeClient):
         handler = FixedLineNumberFileHandler(
             file_path=file_path, total_lines=self._TOTAL_DOCS
         )
-        documents = [
-            json.loads(doc) for doc in handler.read()[skip_ : skip_ + limit_]
-        ]
+        documents = [json.loads(doc) for doc in handler.read()]
+
+        filters = kwargs
+        filters.update({"output_format": resource_type.__name__})
         documents = self._filter(documents, filters=filters)
 
         reverse = False
@@ -83,7 +83,46 @@ class LocalDatalakeClient(AbstractDatalakeClient):
             reverse = True
         documents.sort(key=lambda x: x["timestamp"], reverse=reverse)
 
-        return documents
+        # TODO: review how to apply grouping
+        return [
+            resource_type.parse_obj(doc)
+            for doc in documents[skip_ : limit_ + 1]
+        ]
+
+    def get(
+        self,
+        resource_type: Type,
+        limit_: int = 50,
+        skip_: int = 0,
+        sort: Union[List, str] = ["timestamp__desc"],
+        group_id: Union[List, str] = [],
+        group_fields: Union[List, str] = [],
+        tzinfo: timezone = timezone(timedelta()),
+        **kwargs,
+    ) -> QuerySet:
+        logger.debug(
+            "Retrieving object of type %s from datalake.",
+            resource_type,
+            tags=LogTags.DATALAKE,
+        )
+
+        new_kwargs = {
+            "get_func": "_raw_get",
+            "count_func": "None",
+            "collection": resource_type.Meta.collection_name,
+            "resource_type": resource_type,
+            "limit_": limit_,
+            "skip_": skip_,
+            "sort": sort,
+            "group_id": group_id,
+            "group_fields": group_fields,
+            "tzinfo": tzinfo,
+        }
+        kwargs.update(new_kwargs)
+        return QuerySet(self, **kwargs)
+
+    def get_output(self, query: Query) -> List[Dict]:
+        raise NotImplementedError()
 
     def get_dataframe(
         self,

{splight-lib-3.0.0.dev1 → splight-lib-3.0.0.dev3}/splight_lib/client/datalake/remote_client.py

@@ -5,10 +5,13 @@ from typing import Dict, List, Optional, Union
 
 import pandas as pd
 from furl import furl
+from pydantic import BaseModel
 from retry import retry
-from splight_lib.abstract.client import AbstractRemoteClient
+from splight_abstract import AbstractRemoteClient
+from splight_abstract.datalake import (
+    AbstractDatalakeClient,
+)
 from splight_lib.auth import SplightAuthToken
-from splight_lib.client.datalake.abstract import AbstractDatalakeClient
 from splight_lib.client.exceptions import SPLIGHT_REQUEST_EXCEPTIONS
 from splight_lib.logging._internal import LogTags, get_splight_logger
 from splight_lib.restclient import SplightRestClient

{splight-lib-3.0.0.dev1 → splight-lib-3.0.0.dev3}/splight_lib/client/hub/abstract.py

@@ -1,22 +1,10 @@
 from abc import ABC, abstractmethod, abstractproperty
-from functools import wraps
-from typing import Callable, Dict, List, Tuple, Type
+from typing import Dict, List, Tuple, Type
 
 from pydantic import BaseModel
 from splight_lib.abstract.client import AbstractClient, QuerySet
 
 
-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
-
 
 class AbstractHubSubClient(AbstractClient):
     @abstractmethod

{splight-lib-3.0.0.dev1 → splight-lib-3.0.0.dev3}/splight_lib/client/hub/client.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional, Tuple, Type
+from typing import Dict, List, Optional, Tuple
 
 import requests
 from furl import furl
@@ -7,33 +7,27 @@ from splight_lib.auth import SplightAuthToken
 from splight_lib.client.hub.abstract import (
     AbstractHubClient,
     AbstractHubSubClient,
-    validate_client_resource_type,
 )
-from splight_lib.models.hub import HubComponent, HubComponentVersion
-from splight_lib.settings import settings
 
 
 class _SplightHubGenericClient(AbstractHubSubClient):
     _PREFIX: str = "v2/hub"
-    valid_classes = [
-        HubComponent,
-        HubComponentVersion,
-    ]
     _CLASS_MAP = {
-        HubComponent: "components",
-        HubComponentVersion: "component-versions",
+        'HubComponent': "components",
+        'HubComponentVersion': "component-versions",
     }
 
     def __init__(
         self,
         base_path: str,
+        api_host: str,
         headers: Optional[Dict[str, str]] = {},
         *args,
         **kwargs,
     ):
         super().__init__(*args, **kwargs)
         self._base_url = furl(
-            settings.SPLIGHT_PLATFORM_API_HOST,
+            api_host,
             path=f"{self._PREFIX}/{base_path}/",
         )
         self._session = requests.Session()
@@ -56,10 +50,9 @@ class _SplightHubGenericClient(AbstractHubSubClient):
     def save(self, instance: BaseModel) -> BaseModel:
         raise NotImplementedError
 
-    @validate_client_resource_type
     def _get(
         self,
-        resource_type: Type,
+        resource_type: str,
         first: bool = False,
         limit_: int = -1,
         skip_: int = 0,
@@ -71,14 +64,14 @@ class _SplightHubGenericClient(AbstractHubSubClient):
         assert (
             response.status_code == 200
         ), f"Failed to get components {response.content}"
-        queryset = [resource_type(**v) for v in response.json()["results"]]
+        queryset = response.json()["results"]
         if first:
             return queryset[0] if queryset else None
         return queryset
 
     def count(
         self,
-        resource_type: Type,
+        resource_type: str,
         first=False,
         limit_: int = -1,
         skip_: int = 0,
@@ -92,15 +85,14 @@ class _SplightHubGenericClient(AbstractHubSubClient):
         ), f"Failed to get components {response.content}"
         return response.json()["count"]
 
-    def delete(self, resource_type: Type, id: str) -> None:
+    def delete(self, resource_type: str, id: str) -> None:
         url = self._get_url(resource_type, id)
         response = self._session.delete(url)
         assert (
             response.status_code == 204
         ), f"Failed to delete component {response.content}"
 
-    @validate_client_resource_type
-    def update(self, resource_type: Type, id: str, data: Dict) -> BaseModel:
+    def update(self, resource_type: str, id: str, data: Dict) -> BaseModel:
         url = self._get_url(resource_type, id)
         response = self._session.put(url, json=data)
         assert (
@@ -108,9 +100,8 @@ class _SplightHubGenericClient(AbstractHubSubClient):
         ), f"Failed to update component. {response.content}"
         return resource_type(**response.json())
 
-    @validate_client_resource_type
     def partial_update(
-        self, resource_type: Type, id: str, data: Dict
+        self, resource_type: str, id: str, data: Dict
     ) -> BaseModel:
         url = self._get_url(resource_type, id)
         response = self._session.patch(url, json=data)
@@ -119,8 +110,7 @@ class _SplightHubGenericClient(AbstractHubSubClient):
         ), f"Failed to update component. {response.content}"
         return resource_type.parse_obj(response.json())
 
-    @validate_client_resource_type
-    def rebuild(self, resource_type: Type, id: str) -> None:
+    def rebuild(self, resource_type: str, id: str) -> None:
         url = self._get_url(resource_type, id)
         url = url / "rebuild/"
         response = self._session.post(url, headers=self.headers)
@@ -130,28 +120,34 @@ class _SplightHubGenericClient(AbstractHubSubClient):
 
 
 class SplightHubClient(AbstractHubClient):
-    def __init__(self, *args, **kwargs) -> None:
+    def __init__(
+        self,
+        access_key: str,
+        secret_key: str,
+        api_host: str,
+        *args, **kwargs
+    ) -> None:
         super().__init__()
         token = SplightAuthToken(
-            access_key=settings.SPLIGHT_ACCESS_ID,
-            secret_key=settings.SPLIGHT_SECRET_KEY,
+            access_key=access_key,
+            secret_key=secret_key,
         )
         self._all = _SplightHubGenericClient(
-            base_path="all", headers=token.header
+            base_path="all", headers=token.header, api_host=api_host
         )
         self._mine = _SplightHubGenericClient(
-            base_path="mine", headers=token.header
+            base_path="mine", headers=token.header, api_host=api_host
         )
         self._public = _SplightHubGenericClient(
-            base_path="public", headers=token.header
+            base_path="public", headers=token.header, api_host=api_host
         )
         self._private = _SplightHubGenericClient(
-            base_path="private", headers=token.header
+            base_path="private", headers=token.header, api_host=api_host
         )
         self._setup = _SplightHubGenericClient(
-            base_path="setup", headers=token.header
+            base_path="setup", headers=token.header, api_host=api_host
         )
-        self._host = furl(settings.SPLIGHT_PLATFORM_API_HOST)
+        self._host = furl(api_host)
         self._headers = token.header
 
     def upload(self, data: Dict, files: Dict) -> Tuple:
@@ -161,14 +157,14 @@ class SplightHubClient(AbstractHubClient):
         )
         status_code = response.status_code
         assert status_code == 201, "Unable to upload component to HUB"
-        return response.json(), status_code
+        return response.json()
 
     def download(self, data: Dict) -> Tuple:
         url = self._host / "v2/hub/download/"
         response = requests.post(url, data=data, headers=self._headers)
         status_code = response.status_code
         assert status_code == 200, "Unable to download component"
-        return response.content, status_code
+        return response.content
 
     @property
     def all(self) -> AbstractHubSubClient:

{splight-lib-3.0.0.dev1 → splight-lib-3.0.0.dev3}/splight_lib/models/__init__.py

@@ -7,9 +7,8 @@ from splight_lib.models.component import (
     ComponentObjectInstance,
 )
 from splight_lib.models.file import File
-from splight_lib.models.hub import HubComponent, HubComponentVersion
-from splight_lib.models.native import Boolean, Number, String
 from splight_lib.models.query import Query
+from splight_lib.models.native import Number, String, Boolean
 from splight_lib.models.secret import Secret
 from splight_lib.models.setpoint import SetPoint
 
@@ -19,9 +18,6 @@ __all__ = [
     Asset,
     Attribute,
     Boolean,
-    Component,
-    ComponentObject,
-    ComponentObjectInstance,
     File,
     HubComponent,
     HubComponentVersion,

{splight-lib-3.0.0.dev1 → splight-lib-3.0.0.dev3}/splight_lib/models/base.py

@@ -1,9 +1,7 @@
-import json
-from datetime import datetime, timezone
-from typing import ClassVar, Dict, List, Optional, Set, Tuple
-
-import pandas as pd
-from pydantic import BaseModel, Field, PrivateAttr
+from typing import Dict, List, Optional
+from pydantic import BaseModel, PrivateAttr, Field
+from splight_abstract.database import AbstractDatabaseClient
+from splight_abstract.datalake import AbstractDatalakeClient
 from splight_lib.client.database import DatabaseClientBuilder
 from splight_lib.client.database.abstract import AbstractDatabaseClient
 from splight_lib.client.datalake import DatalakeClientBuilder

{splight-lib-3.0.0.dev1 → splight-lib-3.0.0.dev3}/splight_lib/models/component.py

@@ -21,6 +21,13 @@ from strenum import LowercaseStrEnum
 warnings.filterwarnings("ignore", category=RuntimeWarning)
 
 
+class PrivacyPolicy(LowercaseStrEnum):
+    PUBLIC = auto()
+    PRIVATE = auto()
+
+warnings.filterwarnings("ignore", category=RuntimeWarning)
+
+
 class PrivacyPolicy(LowercaseStrEnum):
     PUBLIC = auto()
     PRIVATE = auto()

splight-lib-3.0.0.dev3/splight_lib/models/hub.py

@@ -0,0 +1,202 @@
+import json
+import os
+from typing import List, Optional
+
+import py7zr
+from pydantic import BaseModel, PrivateAttr, validator
+
+from splight_lib.client.hub.abstract import AbstractHubClient
+from splight_lib.client.hub.client import SplightHubClient
+from splight_lib.models.component import (
+    Binding,
+    Command,
+    ComponentType,
+    Endpoint,
+    InputParameter,
+    Output,
+)
+from splight_lib.settings import settings
+from splight_lib.utils.hub import (
+    COMPRESSION_TYPE,
+    README_FILE_1,
+    README_FILE_2,
+    get_ignore_pathspec,
+    get_spec,
+)
+
+VERIFICATION_CHOICES = ["verified", "unverified", "official"]
+
+
+def get_hub_client() -> AbstractHubClient:
+    return SplightHubClient(
+        access_key=settings.SPLIGHT_ACCESS_ID,
+        secret_key=settings.SPLIGHT_SECRET_KEY,
+        api_host=settings.SPLIGHT_PLATFORM_API_HOST,
+    )
+
+
+class HubComponent(BaseModel):
+    id: Optional[str]
+    name: str
+    version: str
+    splight_cli_version: str
+    build_status: Optional[str]
+    description: Optional[str]
+    privacy_policy: Optional[str] = None
+    component_type: Optional[str] = None
+    tenant: Optional[str] = None
+    readme: Optional[str]
+    picture: Optional[str]
+    file: Optional[str]
+    verification: Optional[str]
+    created_at: Optional[str]
+    last_modified: Optional[str]
+    tags: List[str] = []
+    min_component_capacity: Optional[str]
+    usage_count: int = 0
+
+    input: List[InputParameter] = []
+    output: List[Output] = []
+    commands: List[Command] = []
+    endpoints: List[Endpoint] = []
+    bindings: List[Binding] = []
+
+    _hub_client: AbstractHubClient = PrivateAttr()
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._hub_client = get_hub_client()
+
+    @validator("verification", pre=True, always=True)
+    def set_verification_now(cls, v):
+        if v:
+            assert v in VERIFICATION_CHOICES, "Verification value not allowed."
+        return v
+
+    @classmethod
+    def list_mine(cls, **params) -> List["HubComponent"]:
+        hub_client = get_hub_client()
+        data = hub_client.mine.get(resource_type=cls.__name__, **params)
+        return [cls.parse_obj(obj) for obj in data]
+
+    @classmethod
+    def list_all(cls, **params) -> List["HubComponent"]:
+        hub_client = get_hub_client()
+        data = hub_client.all.get(resource_type=cls.__name__, **params)
+        return [cls.parse_obj(obj) for obj in data]
+
+    @classmethod
+    def list_public(cls, **params) -> List["HubComponent"]:
+        hub_client = get_hub_client()
+        data = hub_client.public.get(resource_type=cls.__name__, **params)
+        return [cls.parse_obj(obj) for obj in data]
+
+    @classmethod
+    def list_private(cls, **params) -> List["HubComponent"]:
+        hub_client = get_hub_client()
+        data = hub_client.private.get(resource_type=cls.__name__, **params)
+        return [cls.parse_obj(obj) for obj in data]
+
+    @classmethod
+    def list_setup(cls, **params) -> List["HubComponent"]:
+        hub_client = get_hub_client()
+        data = hub_client.setup.get(resource_type=cls.__name__, **params)
+        return [cls.parse_obj(obj) for obj in data]
+
+    @classmethod
+    def retrieve_mine(cls, id: str) -> "HubComponent":
+        hub_client = get_hub_client()
+        data = hub_client.mine.get(
+            resource_type=cls.__name__, id=id, first=True
+        )
+        return cls.parse_obj(data)
+
+    @classmethod
+    def retrieve_all(cls, id: str) -> "HubComponent":
+        hub_client = get_hub_client()
+        data = hub_client.all.get(
+            resource_type=cls.__name__, id=id, first=True
+        )
+        return cls.parse_obj(data)
+
+    @classmethod
+    def retrieve_public(cls, id: str) -> "HubComponent":
+        hub_client = get_hub_client()
+        data = hub_client.public.get(
+            resource_type=cls.__name__, id=id, first=True
+        )
+        return cls.parse_obj(data)
+
+    @classmethod
+    def retrieve_private(cls, id: str) -> "HubComponent":
+        hub_client = get_hub_client()
+        data = hub_client.private.get(
+            resource_type=cls.__name__, id=id, first=True
+        )
+        return cls.parse_obj(data)
+
+    @classmethod
+    def retrieve_setup(cls, id: str) -> "HubComponent":
+        hub_client = get_hub_client()
+        data = hub_client.setup.get(
+            resource_type=cls.__name__, id=id, first=True
+        )
+        return cls.parse_obj(data)
+
+    def delete(self):
+        return self._hub_client.mine.delete(self.id)
+
+    def download(self):
+        return self._hub_client.download(data=self.dict())
+
+    @classmethod
+    def upload(cls, path: str):
+        hub_client = get_hub_client()
+        spec = get_spec(path)
+        name = spec["name"]
+        version = spec["version"]
+        file_name = f"{name}-{version}.{COMPRESSION_TYPE}"
+        ignore_pathspec = get_ignore_pathspec(path)
+        versioned_name = f"{name}-{version}"
+        readme_path = os.path.join(path, README_FILE_1)
+        if not os.path.exists(readme_path):
+            readme_path = os.path.join(path, README_FILE_2)
+        with py7zr.SevenZipFile(file_name, "w") as archive:
+            for root, _, files in os.walk(path):
+                if ignore_pathspec and ignore_pathspec.match_file(root):
+                    continue
+                for file in files:
+                    if ignore_pathspec and ignore_pathspec.match_file(
+                        os.path.join(root, file)
+                    ):
+                        continue
+                    filepath = os.path.join(root, file)
+                    archive.write(filepath, os.path.join(versioned_name, file))
+        data = {
+            "name": name,
+            "version": version,
+            "splight_cli_version": spec["splight_cli_version"],
+            "privacy_policy": spec.get("privacy_policy", "private"),
+            "tags": spec.get("tags", []),
+            "custom_types": json.dumps(spec.get("custom_types", [])),
+            "input": json.dumps(spec.get("input", [])),
+            "output": json.dumps(spec.get("output", [])),
+            "component_type": spec.get(
+                "component_type", ComponentType.CONNECTOR.value
+            ),
+            "commands": json.dumps(spec.get("commands", [])),
+            "bindings": json.dumps(spec.get("bindings", [])),
+            "endpoints": json.dumps(spec.get("endpoints", [])),
+        }
+        files = {
+            "file": open(file_name, "rb"),
+            "readme": open(readme_path, "rb"),
+        }
+        component = hub_client.upload(data=data, files=files)
+        if os.path.exists(file_name):
+            os.remove(file_name)
+        return cls.parse_obj(component)
+
+
+class HubComponentVersion(HubComponent):
+    pass

{splight-lib-3.0.0.dev1 → splight-lib-3.0.0.dev3}/splight_lib/settings.py

@@ -29,8 +29,8 @@ def yml_config_setting(settings: BaseSettings) -> Dict[str, Any]:
 
 
 class SplightSettings(BaseSettings, Singleton):
-    SPLIGHT_ACCESS_ID: str
-    SPLIGHT_SECRET_KEY: str
+    SPLIGHT_ACCESS_ID: str = ""
+    SPLIGHT_SECRET_KEY: str = ""
     SPLIGHT_PLATFORM_API_HOST: str = "https://api.splight-ai.com"
 
     # Parameters for local environment

splight-lib-3.0.0.dev3/splight_lib/testing/__init__.py

@@ -0,0 +1,102 @@
+import os
+from datetime import datetime
+from typing import Any, Dict, List
+
+import pytest
+from pytest_mock import MockerFixture
+
+from splight_lib.component.spec import Spec
+from splight_lib.models import (
+    Asset,
+    Attribute,
+    Component,
+    ComponentObjectInstance,
+    File,
+)
+from splight_lib.models.component import CustomType, Parameter
+from splight_lib.settings import settings
+
+settings.configure(LOCAL_ENVIRONMENT=True)
+
+FAKE_NATIVE_VALUES = {
+    "int": 1,
+    "bool": True,
+    "str": "fake",
+    "float": 5.5,
+    "datetime": datetime(2022, 12, 18),
+    "url": "www.google.com",
+}
+
+FAKE_DATABASE_VALUES = {
+    "Component": Component(name="ComponentTest", version="1.0.0"),
+    "Asset": Asset(name="AssetTest"),
+    "Attribute": Attribute(name="AttrTest"),
+    "File": File(file=""),
+}
+
+
+def get_test_value(type_: str, custom_types: Dict[str, CustomType]) -> Any:
+    if type_ in FAKE_NATIVE_VALUES:
+        value = FAKE_NATIVE_VALUES.get(type_)
+    elif type_ in FAKE_DATABASE_VALUES:
+        value = FAKE_DATABASE_VALUES.get(type_)
+    else:
+        custom_type_def = custom_types[type_]
+        model_class = ComponentObjectInstance.from_custom_type(custom_type_def)
+        aux_value = component_object_attributes(
+            custom_type_def.fields, custom_types
+        )
+        value = model_class.parse_obj(aux_value)
+    return value
+
+
+def component_object_attributes(
+    parameters: List[Parameter], custom_types: Dict[str, CustomType]
+) -> Dict[str, Any]:
+    values_dict = {
+        param.name: get_test_value(param.type, custom_types)
+        for param in parameters
+    }
+    return values_dict
+
+
+def get_test_input(spec: Spec):
+    input_model_class = spec.get_input_model()
+    custom_types = {ct.name: ct for ct in spec.custom_types}
+    input_fake_values = {}
+    for param in spec.input:
+        param_name = param.name
+        type_ = param.type
+        value = get_test_value(type_, custom_types)
+
+        if param.multiple:
+            value = [value]
+
+        input_fake_values.update({param_name: value})
+    return input_model_class.parse_obj(input_fake_values)
+
+
+@pytest.fixture(autouse=True)
+def mock_component(mocker: MockerFixture):
+    # Patch method for checking duplicated component
+    mocker.patch(
+        (
+            "splight_lib.component.abstract.SplightBaseComponent."
+            "_check_duplicated_component"
+        ),
+        return_value=None,
+    )
+
+    # Patch HealthCheckProcessor
+    mocker.patch(
+        "splight_lib.execution.ExecutionClient.start", return_value=None
+    )
+
+    base_path = os.getcwd()
+    spec = Spec.from_file(os.path.join(base_path, "spec.json"))
+    # Generate fake input for testing
+    mocker.patch(
+        "splight_lib.component.spec.Spec.component_input",
+        return_value=get_test_input(spec),
+    )
+    return mocker

splight-lib-3.0.0.dev3/splight_lib/utils/hub.py

@@ -0,0 +1,27 @@
+import os
+from typing import Any, Dict, Optional
+import pathspec
+import json
+
+SPLIGHT_IGNORE = ".splightignore"
+COMPRESSION_TYPE = "7z"
+SPEC_FILE = "spec.json"
+README_FILE_1 = "README.md"
+README_FILE_2 = "README"
+
+
+def get_spec(path: str) -> Dict[str, Any]:
+    with open(os.path.join(path, SPEC_FILE)) as fid:
+        return json.load(fid)
+
+
+def get_ignore_pathspec(path: str) -> Optional[pathspec.PathSpec]:
+    try:
+        with open(
+            os.path.join(path, SPLIGHT_IGNORE), "r"
+        ) as splightignore:
+            return pathspec.PathSpec.from_lines(
+                "gitwildmatch", splightignore
+            )
+    except FileNotFoundError:
+        return None

{splight-lib-3.0.0.dev1 → splight-lib-3.0.0.dev3}/splight_lib.egg-info/PKG-INFO

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

{splight-lib-3.0.0.dev1 → splight-lib-3.0.0.dev3}/splight_lib.egg-info/SOURCES.txt

@@ -72,5 +72,7 @@ splight_lib/restclient/__init__.py
 splight_lib/restclient/client.py
 splight_lib/restclient/exceptions.py
 splight_lib/restclient/types.py
+splight_lib/testing/__init__.py
 splight_lib/utils/__init__.py
-splight_lib/utils/custom_model.py
+splight_lib/utils/custom_model.py
+splight_lib/utils/hub.py

splight-lib-3.0.0.dev1/splight_lib/models/hub.py

@@ -1,35 +0,0 @@
-from typing import List, Optional
-
-from pydantic import BaseModel, validator
-
-VERIFICATION_CHOICES = ["verified", "unverified", "official"]
-
-
-class HubComponent(BaseModel):
-    id: Optional[str]
-    name: str
-    splight_cli_version: str
-    build_status: Optional[str]
-    description: Optional[str]
-    privacy_policy: Optional[str] = None
-    component_type: Optional[str] = None
-    tenant: Optional[str] = None
-    readme: Optional[str]
-    picture: Optional[str]
-    file: Optional[str]
-    verification: Optional[str]
-    created_at: Optional[str]
-    last_modified: Optional[str]
-    tags: List[str] = []
-    min_component_capacity: Optional[str]
-    usage_count: int = 0
-
-    @validator("verification", pre=True, always=True)
-    def set_verification_now(cls, v):
-        if v:
-            assert v in VERIFICATION_CHOICES, "Verification value not allowed."
-        return v
-
-
-class HubComponentVersion(HubComponent):
-    pass