logs-py 4.0.7__py3-none-any.whl

LOGS/Entities/__init__.py

@@ -0,0 +1,118 @@
+"""
+This package is written for the LOGS Repository.
+
+It's objects can be used to write your own dataset parser.
+
+License:
+Permission to use this library and all of its contents is
+strictly permitted to the Signals Company.
+"""
+
+from .Attachment import *
+from .AttachmentRequestParameter import *
+from .Attachments import *
+from .AxisNaming import *
+from .Bridge import *
+from .BridgeClientInfo import *
+from .BridgeMinimal import *
+from .BridgeRequestParameter import *
+from .BridgeType import *
+from .CustomField import *
+from .CustomFieldModels import *
+from .CustomFieldRequestParameter import *
+from .CustomType import *
+from .CustomTypeMinimal import *
+from .CustomTypeRequestParameter import *
+from .DataFormat import *
+from .DataFormatInstrumentMinimal import *
+from .DataFormatInstrumentRequestParameter import *
+from .DataFormatMinimal import *
+from .DataFormatRequestParameter import *
+from .Dataset import *
+from .DatasetCreator import *
+from .DatasetInfo import *
+from .DatasetMatching import *
+from .DatasetMatchTypes import *
+from .DatasetMinimal import *
+from .DatasetRequestParameter import *
+from .Datasets import *
+from .DatasetUploadParameter import *
+from .DataSource import *
+from .DataSourceMinimal import *
+from .DataSourceRequestParameter import *
+from .DataSourceStatus import *
+from .DataSourceStatusIterator import *
+from .DataSourceStatusRequestParameter import *
+from .Datatrack import *
+from .DatatrackFormattedTable import *
+from .DatatrackImage import *
+from .DatatrackNumericArray import *
+from .DatatrackNumericMatrix import *
+from .Entities import *
+from .EntitiesRequestParameter import *
+from .EntityOriginWriteModelWithId import *
+from .FileEntry import *
+from .HierarchyLeaf import *
+from .HierarchyNode import *
+from .InventoryItem import *
+from .InventoryItemMinimal import *
+from .InventoryItemRequestParameter import *
+from .LabNotebook import *
+from .LabNotebookEntries import *
+from .LabNotebookEntryContent import *
+from .LabNotebookEntryMinimal import *
+from .LabNotebookEntryRequestParameter import *
+from .LabNotebookExperiment import *
+from .LabNotebookExperimentMinimal import *
+from .LabNotebookExperimentRequestParameter import *
+from .LabNotebookExperiments import *
+from .LabNotebookMinimal import *
+from .LabNotebookModels import *
+from .LabNotebookRequestParameter import *
+from .LabNotebooks import *
+from .LabNotebookTemplate import *
+from .LabNotebookTemplateMinimal import *
+from .LabNotebookTemplateRequestParameter import *
+from .LabNotebookTemplates import *
+from .Method import *
+from .MethodMinimal import *
+from .MethodRequestParameter import *
+from .Origin import *
+from .OriginMinimal import *
+from .OriginRequestParameter import *
+from .Origins import *
+from .ParserLog import *
+from .Person import *
+from .PersonCategory import *
+from .PersonMinimal import *
+from .PersonRequestParameter import *
+from .Persons import *
+from .Project import *
+from .ProjectMinimal import *
+from .ProjectPersonPermission import *
+from .ProjectRequestParameter import *
+from .Projects import *
+from .Role import *
+from .RoleRequestParameter import *
+from .Sample import *
+from .SampleMinimal import *
+from .SampleRequestParameter import *
+from .Samples import *
+from .SharedContent import *
+from .SharedContentRequestParameter import *
+from .SharedContents import *
+from .Track import *
+from .TrackData import *
+from .TrackImage import *
+from .TrackImageData import *
+from .TrackMatrix import *
+from .TrackMatrixData import *
+from .TrackSettings import *
+from .TrackXY import *
+from .TrackXYComplex import *
+from .TrackXYComplexData import *
+from .TrackXYData import *
+from .Vendor import *
+from .VendorMinimal import *
+from .VendorRequestParameter import *
+from .Vendors import *

LOGS/Entity/ConnectedEntity.py

@@ -0,0 +1,170 @@
+import inspect
+from typing import Any, Callable, List, Optional, Type, TypeVar, Union, cast
+
+from LOGS.Auxiliary.Exceptions import EntityNotConnectedException
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Entity.SerializableContent import SerializableContent
+from LOGS.LOGSConnection import LOGSConnection
+
+_T = TypeVar("_T")
+
+
+class ConnectedEntity(SerializableContent):
+    _connection: Optional[LOGSConnection] = None
+    _endpoint: Optional[List[str]] = None
+    _uiEndpoint: Optional[List[str]] = None
+    _noSerialize = ["connection", "cachePath", "cacheId", "cacheDir"]
+    _cacheDir: Optional[str] = None
+    _cacheId: str = cast(str, None)
+
+    def __init__(self, ref=None, connection: Optional[LOGSConnection] = None):
+        self._connection = connection
+
+        if not self._uiEndpoint and self._endpoint and len(self._endpoint) == 1:
+            self._uiEndpoint = ["#" + self._endpoint[0]]
+
+        super().__init__(ref=ref)
+
+    def _getConnection(self):
+        if not self._connection:
+            raise EntityNotConnectedException(self)
+        return self._connection
+
+    def _getConnectionData(self):
+        if not self._endpoint:
+            raise NotImplementedError(
+                "Endpoint missing for of entity type %a."
+                % (
+                    type(self).__name__
+                    if type(self).__name__ != ConnectedEntity.__name__
+                    else "unknown"
+                )
+            )
+
+        return self._getConnection(), self._endpoint
+
+    def _setConnection(self, value):
+        self._connection = Tools.checkAndConvert(
+            value, LOGSConnection, "connection", allowNone=True
+        )
+        for k in self.__dict__:
+            a = getattr(self, k)
+            if issubclass(type(a), ConnectedEntity):
+                cast(ConnectedEntity, a)._setConnection(self._connection)
+
+    def clearCache(self):
+        raise NotImplementedError(
+            "Clearing cache of %a class is not implemented." % type(self).__name__
+        )
+
+    @classmethod
+    def checkAndConvertWithConnection(
+        cls,
+        value: Any,
+        fieldType: Type[_T],
+        fieldName: Optional[str] = None,
+        converter: Optional[Callable[[Any], _T]] = None,
+        allowNone=False,
+        connection: Optional[LOGSConnection] = None,
+    ) -> _T:
+        if (
+            inspect.isclass(fieldType)
+            and issubclass(fieldType, ConnectedEntity)
+            and isinstance(value, dict)
+        ):
+            return cast(Any, fieldType)(ref=value, connection=connection)
+
+        return Tools.checkAndConvert(value, fieldType, fieldName, converter, allowNone)
+
+    @classmethod
+    def checkListAndConvertWithConnection(
+        cls,
+        value: Any,
+        fieldType: Type[_T],
+        fieldName: Optional[str] = None,
+        converter: Optional[Callable[[Any], _T]] = None,
+        allowNone: bool = False,
+        connection: Optional[LOGSConnection] = None,
+    ) -> List[_T]:
+        if isinstance(value, (list, tuple)):
+            value = [
+                cls.checkAndConvertWithConnection(
+                    v, fieldType, fieldName, converter, allowNone, connection
+                )
+                for v in value
+            ]
+
+        return Tools.checkListAndConvert(
+            value=value,
+            fieldType=fieldType,
+            fieldName=fieldName,
+            converter=converter,
+            allowNone=allowNone,
+        )
+
+    def checkAndConvert(
+        self,
+        value: Any,
+        fieldType: Union[Type[_T], List[Type[_T]]],
+        fieldName: Optional[str] = None,
+        converter: Optional[Callable[[Any], _T]] = None,
+        allowNone=False,
+    ) -> _T:
+        if (
+            inspect.isclass(fieldType)
+            and issubclass(fieldType, ConnectedEntity)
+            and isinstance(value, dict)
+        ):
+            return cast(Any, fieldType)(ref=value, connection=self._connection)
+
+        return super().checkAndConvert(
+            value, fieldType, fieldName, converter, allowNone
+        )
+
+    def checkListAndConvert(
+        self,
+        value: Any,
+        fieldType: Type[_T],
+        fieldName: Optional[str] = None,
+        converter: Optional[Callable[[Any], _T]] = None,
+        allowNone: bool = False,
+        singleToList: bool = False,
+        length: int = -1,
+    ) -> List[_T]:
+        if isinstance(value, (list, tuple)):
+            value = [
+                self.checkAndConvert(v, fieldType, fieldName, converter, allowNone)
+                for v in value
+            ]
+
+        return super().checkListAndConvert(
+            value=value,
+            fieldType=fieldType,
+            fieldName=fieldName,
+            converter=converter,
+            allowNone=allowNone,
+            singleToList=singleToList,
+            length=length,
+        )
+
+    @property
+    def identifier(self):
+        return "%s" % (type(self).__name__)
+
+    @property
+    def cacheDir(self) -> Optional[str]:
+        return self._cacheDir
+
+    @cacheDir.setter
+    def cacheDir(self, value):
+        self._cacheDir = Tools.checkAndConvert(value, str, "cacheDir", allowNone=True)
+
+    @property
+    def cacheId(self) -> str:
+        if self._cacheId is None:
+            if not hasattr(self, "id"):
+                setattr(self, "id", Tools.generateRandomString())
+
+            return f"{type(self).__name__}_{str(getattr(self, 'id'))}"
+        else:
+            return self._cacheId

LOGS/Entity/Entity.py

@@ -0,0 +1,203 @@
+from typing import Any, Optional, cast
+
+from LOGS.Auxiliary import MinimalModelGenerator, Tools
+from LOGS.Auxiliary.Constants import Constants
+from LOGS.Auxiliary.Exceptions import (
+    EntityDeletingException,
+    EntityFetchingException,
+    EntityNotFoundException,
+    EntityUpdatingException,
+)
+from LOGS.Entity.ConnectedEntity import ConnectedEntity
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.LOGSConnection import LOGSConnection
+
+# SELF = TypeVar("SELF", bound="Entity")
+
+
+class Entity(ConnectedEntity):
+    _id: Constants.ID_TYPE
+    _defaultRequestParameter: dict = EntityRequestParameter().toDict()
+
+    def __init__(
+        self,
+        ref=None,
+        id: Optional[Constants.ID_TYPE] = None,
+        connection: Optional[LOGSConnection] = None,
+    ):
+        """Represents a connected LOGS entity type"""
+        if id:
+            self._id = id
+
+        super().__init__(ref=ref, connection=connection)
+
+    def _getConnectionData(self):
+        (connection, endpoint) = super()._getConnectionData()
+
+        if not self.id:
+            raise EntityNotFoundException(self)
+
+        return connection, endpoint, self.id
+
+    def __str__(self):
+        return Tools.ObjectToString(self)
+
+    def getUIUrl(self) -> str:
+        uiEndpoint = self._uiEndpoint
+        if not uiEndpoint:
+            raise NotImplementedError(
+                "No UI endpoint specified for entity type %a."
+                % (
+                    type(self).__name__
+                    if type(self).__name__ != Entity.__name__
+                    else "unknown"
+                )
+            )
+        connection = self._getConnection()
+
+        return connection.getUIEndpointUrl(uiEndpoint + [str(self.id)])
+
+    def _fetchEntity(self, connection: LOGSConnection):
+        if not self._endpoint:
+            raise NotImplementedError(
+                "Fetching of entity type %a is not implemented."
+                % (
+                    type(self).__name__
+                    if type(self).__name__ != Entity.__name__
+                    else "unknown"
+                )
+            )
+
+        ref, responseError = connection.getEndpoint(
+            cast(Any, self._endpoint + [str(self.id)]), self._defaultRequestParameter
+        )
+        if responseError:
+            raise EntityFetchingException(entity=self, responseError=responseError)
+
+        if isinstance(ref, dict) and "url" in ref:
+            del ref["url"]
+        self._fromRef(ref, type(self))
+        self._setConnection(connection)
+
+    def fetch(self):
+        self._fetchEntity(self._getConnection())
+
+    def _restoreEntity(self, connection: LOGSConnection):
+        if not self._endpoint:
+            raise NotImplementedError(
+                "Updating of entity type %a is not implemented."
+                % (
+                    type(self).__name__
+                    if type(self).__name__ != Entity.__name__
+                    else "unknown"
+                )
+            )
+
+        if not self.id:
+            raise EntityNotFoundException(self)
+
+        data, responseError = connection.postEndpoint(
+            self._endpoint + ["restore", self.id], data=self.toDict()
+        )
+        if responseError:
+            raise EntityUpdatingException(entity=self, responseError=responseError)
+
+        self.override(data)
+
+    def _updateEntity(self, connection: LOGSConnection):
+        if not self._endpoint:
+            raise NotImplementedError(
+                "Updating of entity type %a is not implemented."
+                % (
+                    type(self).__name__
+                    if type(self).__name__ != Entity.__name__
+                    else "unknown"
+                )
+            )
+
+        if not self.id:
+            raise EntityNotFoundException(self)
+
+        data, responseError = connection.putEndpoint(
+            self._endpoint + [self.id], data=self.toDict()
+        )
+        if responseError:
+            raise EntityUpdatingException(entity=self, responseError=responseError)
+
+        self.override(data)
+
+    def _deleteEntity(self, connection: LOGSConnection, permanently: bool = False):
+        if not self._endpoint:
+            raise NotImplementedError(
+                "Deleting of entity type %a is not implemented."
+                % (
+                    type(self).__name__
+                    if type(self).__name__ != Entity.__name__
+                    else "unknown"
+                )
+            )
+
+        if not self.id:
+            raise EntityNotFoundException(self)
+
+        _, responseError = connection.deleteEndpoint(
+            self._endpoint + [self.id], parameters={"deletePermanently": permanently}
+        )
+        if hasattr(self, "isDeleted"):
+            setattr(self, "isDeleted", True)
+
+        if permanently:
+            self._connection = None
+
+        if responseError:
+            if [
+                e
+                for e in responseError.errorStringList
+                if "Soft-Delete is not supported" in e
+            ]:
+                raise EntityDeletingException(
+                    entityIds=self.id,
+                    errors=[
+                        "This entity cannot be trashed.",
+                        "Please use 'permanently = true' parameter.",
+                    ],
+                )
+            else:
+                raise EntityDeletingException(
+                    entityIds=self.id, responseError=responseError
+                )
+
+    def update(self):
+        self._updateEntity(self._getConnection())
+
+    def restore(self):
+        self._restoreEntity(self._getConnection())
+
+    def delete(self, permanently: bool = False):
+        self._deleteEntity(self._getConnection(), permanently=permanently)
+
+    def toMinimal(self):
+        return MinimalModelGenerator.MinimalFromSingle(
+            self.toDict(), type(self).__name__, None, self._getConnection()
+        )
+
+    @property
+    def identifier(self):
+        name = (
+            f" '{getattr(self, 'name')}'"
+            if hasattr(self, "name") and getattr(self, "name")
+            else ""
+        )
+        return "%s(id:%s)%s" % (
+            type(self).__name__,
+            str(self.id),
+            name,
+        )
+
+    @property
+    def id(self):
+        return self._id
+
+    @id.setter
+    def id(self, value):
+        self._id = value

LOGS/Entity/EntityConnector.py

@@ -0,0 +1,70 @@
+from typing import Generic, List, Optional, TypeVar
+
+from LOGS.Auxiliary.Exceptions import NotConnectedException
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Entity.Entity import Entity
+from LOGS.Entity.SerializableContent import SerializableContent
+from LOGS.LOGSConnection import LOGSConnection, ResponseTypes
+
+# SELF = TypeVar("SELF", bound="EntityConnector")
+
+_T = TypeVar("_T", bound=Entity)
+
+
+class EntityConnector(Generic[_T]):
+    """Represents a connected LOGS entity iterator"""
+
+    _endpoint: Optional[List[str]] = None
+    _firstUrl: Optional[str] = None
+
+    _parameters: SerializableContent
+    _responseType: ResponseTypes = ResponseTypes.JSON
+    _includeUrl: bool = True
+    _connection: Optional[LOGSConnection] = None
+
+    def __init__(self, connection: Optional[LOGSConnection]):
+        self._connection = connection
+
+    def _getConnection(self):
+        if not self._connection:
+            raise NotConnectedException(
+                "%s iterator not connected." % type(self).__name__
+            )
+        return self._connection
+
+    def _getConnectionData(self):
+        if not self._endpoint:
+            raise NotImplementedError(
+                "Endpoint missing for %s iterator." % (type(self).__name__.lower())
+            )
+
+        return self._getConnection(), self._endpoint
+
+    def __str__(self):
+        s = ""
+        if self._endpoint:
+            s = "/" + "/".join(self._endpoint)
+        return "<%s %a>" % (type(self).__name__, s)
+
+    def getBaseUrl(self):
+        return (
+            self._firstUrl
+            if self._firstUrl
+            else (
+                self._connection.getEndpointUrl(
+                    endpoint=self._endpoint if self._endpoint else ""
+                )
+                if self._connection
+                else ""
+            )
+        )
+
+    @property
+    def connection(self) -> Optional[LOGSConnection]:
+        return self._connection
+
+    @connection.setter
+    def connection(self, value):
+        self._connection = Tools.checkAndConvert(
+            value, LOGSConnection, "connection", allowNone=True
+        )