logs-py 4.0.7__py3-none-any.whl

LOGS/Auxiliary/Exceptions.py

@@ -0,0 +1,341 @@
+from typing import TYPE_CHECKING, Any, List, Optional, Type, TypeVar, Union, cast
+
+from LOGS.Auxiliary.Constants import Constants
+from LOGS.Auxiliary.Tools import Tools
+
+if TYPE_CHECKING:
+    from LOGS.Auxiliary.LOGSErrorResponse import LOGSErrorResponse
+    from LOGS.Converter.Conversion import Conversion
+    from LOGS.Entity.ConnectedEntity import ConnectedEntity
+    from LOGS.Entity.Entity import Entity
+
+
+class LOGSException(Exception):
+    title: Optional[str] = None
+    details: Optional[str] = None
+    status: Optional[int] = None
+    # type: Optional[str] = None
+
+    def __init__(
+        self,
+        message: Optional[Union[List[str], str]] = None,
+        responseError: Optional["LOGSErrorResponse"] = None,
+    ):
+        responseMessage = None
+        if responseError:
+            self._fromResponse(responseError)
+            responseMessage = "\n" + responseError.errorString()
+
+        if message:
+            if isinstance(message, list):
+                message = self.formatErrorMessage(message)
+            message = cast(str, message)
+            super().__init__(Tools.convertToNativeNewline(message))
+        elif responseMessage:
+            super().__init__(Tools.convertToNativeNewline(cast(str, responseMessage)))
+        else:
+            super().__init__()
+
+    @classmethod
+    def formatErrorMessage(cls, errors: List[str], indent: str = " " * 2):
+        indent *= 2
+        if len(errors) == 1:
+            return errors[0]
+        if len(errors) > 1:
+            return "\n" + indent + ("\n" + indent).join(errors)
+        else:
+            return ""
+
+    def _fromResponse(self, response: "LOGSErrorResponse"):
+        self.title = response.title if response.title else response.header
+        self.status = response.status
+
+
+TEntity = TypeVar("TEntity", bound="Entity")
+
+
+class LOGSMultilineException(LOGSException):
+    def __init__(
+        self,
+        errors: Optional[List[str]] = None,
+        responseError: Optional["LOGSErrorResponse"] = None,
+    ):
+        if not errors and responseError:
+            errors = responseError.errorStringList
+
+        super().__init__(
+            self._createMessage(errors=errors), responseError=responseError
+        )
+
+    @classmethod
+    def _createMessage(
+        cls,
+        errors: Optional[List[str]] = None,
+    ):
+        indent = Constants.exceptionIndentation
+        message = ""
+
+        indent *= 2
+
+        if errors:
+            message = errors.pop(0)
+
+        if errors:
+            message += "\n" + indent + ("\n" + indent).join(errors)
+
+        return message
+
+
+class EntityIncompleteException(LOGSException):
+    def __init__(
+        self,
+        entity: Union["Entity", "ConnectedEntity"],
+        errors: Optional[List[str]] = None,
+        parameterName: Optional[str] = None,
+        functionName: Optional[str] = None,
+        responseError: Optional["LOGSErrorResponse"] = None,
+        hasFetchFull: bool = True,
+    ):
+        if not errors and responseError:
+            errors = responseError.errorStringList
+
+        super().__init__(
+            self._createMessage(
+                entity=entity,
+                errors=errors,
+                functionName=functionName,
+                parameterName=parameterName,
+                hasFetchFull=hasFetchFull,
+            ),
+            responseError=responseError,
+        )
+
+    def _createMessage(
+        self,
+        entity: Union["Entity", "ConnectedEntity"],
+        errors: Optional[List[str]] = None,
+        parameterName: Optional[str] = None,
+        functionName: Optional[str] = None,
+        hasFetchFull: bool = True,
+    ):
+        indent = Constants.exceptionIndentation
+        message = ""
+
+        name = f" '{parameterName}' " if parameterName else " "
+        func = []
+        if functionName:
+            func.append(f"'{functionName}'")
+
+        if hasFetchFull:
+            func.append(f"'fetchFull()'")
+
+        message = f"Additional field{name}of entity {entity.identifier} was not fetched for efficiency reasons. Use {' or '.join(func)} method to fetch this parameter"
+
+        indent *= 2
+        if errors:
+            message += self.formatErrorMessage(errors=errors, indent=indent)
+            # lines = errors.split("\n")
+            # if len(lines) > 1:
+            #     message += ":\n" + indent + ("\n" + indent).join(lines)
+            # else:
+            #     message += ": " + errors
+        else:
+            message += "."
+
+        return message
+
+
+class EntityAPIException(LOGSException):
+    _action = "communicate"
+
+    def __init__(
+        self,
+        entity: Optional[Union[TEntity, List[TEntity]]] = None,
+        errors: Optional[List[str]] = None,
+        responseError: Optional["LOGSErrorResponse"] = None,
+    ):
+        if not errors and responseError:
+            errors = responseError.errorStringList
+
+        super().__init__(
+            self._createMessage(entity=entity, errors=errors),
+            responseError=responseError,
+        )
+
+    def _createMessage(
+        self,
+        entity: Optional[Union[TEntity, List[TEntity]]],
+        errors: Optional[List[str]] = None,
+    ):
+        from LOGS.Entity.Entity import Entity
+
+        indent = Constants.exceptionIndentation
+        message = ""
+        if isinstance(entity, list):
+            message = "%sCould not %s %s %a" % (
+                "\n" + indent if errors and len(errors) > 1 else "",
+                self._action,
+                Tools.plural("entity", entity),
+                Tools.eclipsesJoin(", ", [e.identifier for e in entity]),
+            )
+        elif isinstance(entity, Entity):
+            message = "Could not %s entity %a" % (self._action, entity.identifier)
+        else:
+            message = "%s entity failed" % Tools.gerundVerb(self._action.capitalize())
+
+        # indent *= 2
+        if errors:
+            message += ": " + self.formatErrorMessage(errors=errors, indent=indent)
+            # lines = error.split("\n")
+            # if len(lines) > 1:
+            #     message += ":\n" + indent + ("\n" + indent).join(lines)
+            # else:
+            #     message += ": " + error
+        else:
+            message += "."
+
+        return message
+
+
+class EntityFetchingException(EntityAPIException):
+    _action = "fetch"
+
+
+class EntityUpdatingException(EntityAPIException):
+    _action = "update"
+
+
+class EntityCreatingException(EntityAPIException):
+    _action = "create"
+
+
+class EntityDeletingException(LOGSException):
+    _action = "delete"
+
+    def __init__(
+        self,
+        entityIds: Optional[Union[Constants.ID_TYPE, List[Constants.ID_TYPE]]] = None,
+        errors: Optional[List[str]] = None,
+        responseError: Optional["LOGSErrorResponse"] = None,
+    ):
+        if not errors and responseError:
+            errors = responseError.errorStringList
+
+        super().__init__(
+            self._createMessage(entityIds=entityIds, errors=errors),
+            responseError=responseError,
+        )
+
+    def _createMessage(
+        self,
+        entityIds: Optional[Union[Constants.ID_TYPE, List[Constants.ID_TYPE]]],
+        errors: Optional[List[str]] = None,
+    ):
+        from LOGS.Entity.Entity import Entity
+
+        indent = Constants.exceptionIndentation
+        message = ""
+        if isinstance(entityIds, list):
+            message = "%sCould not %s %s %a" % (
+                "\n" + indent if errors and len(errors) > 1 else "",
+                self._action,
+                Tools.plural("entity", entityIds),
+                Tools.eclipsesJoin(", ", [str(id) for id in entityIds]),
+            )
+        elif isinstance(entityIds, Entity):
+            message = "Could not %s entity %a" % (self._action, entityIds.identifier)
+        else:
+            message = "%s entity failed" % (Tools.gerundVerb(self._action.capitalize()))
+
+        indent *= 2
+        if errors:
+            message += ": " + self.formatErrorMessage(errors=errors, indent=indent)
+            # lines = error.split("\n")
+            # if len(lines) > 1:
+            #     message += ":\n" + indent + ("\n" + indent).join(lines)
+            # else:
+            #     message += ": " + error
+        else:
+            message += "."
+
+        return message
+
+
+class EntityNotFoundException(LOGSException):
+    def __init__(self, entity=None):
+        ident = ""
+        if entity:
+            ident = " " + str(entity.id)
+            name = entity.name
+            if name:
+                ident += " " + name
+            ident += " (id:%s)" % str(entity.id)
+
+        super().__init__("%s%s is not connected." % (type(entity).__name__, ident))
+
+
+class NotConnectedException(LOGSException):
+    def __init__(self, message: Optional[str] = None):
+        if message:
+            super().__init__(message=message)
+        else:
+            super().__init__("Not connected.")
+
+
+class EntityNotConnectedException(NotConnectedException):
+    def __init__(
+        self,
+        entity: Optional["ConnectedEntity"] = None,
+        identifier: Optional[str] = None,
+    ):
+        if entity:
+            super().__init__(
+                "Entity %a is not connected to a LOGS instance." % (entity.identifier)
+            )
+        elif identifier:
+            super().__init__(
+                "Entity %a is not connected to a LOGS instance." % (identifier)
+            )
+        else:
+            super().__init__("Entity is not connected to a LOGS instance.")
+
+
+class TypedEntityNotConnectedException(NotConnectedException):
+    def __init__(
+        self,
+        entity: Union[Type["ConnectedEntity"], "ConnectedEntity"],
+    ):
+        from LOGS import LOGS
+
+        t = entity if isinstance(entity, type) else type(entity)
+
+        super().__init__(
+            f"Typed entity '{t.__name__}' is not connected to a LOGS instance. Please use {LOGS.__name__}().getEntityClass()."
+        )
+
+
+class IllegalFieldValueException(LOGSException):
+
+    def __init__(
+        self,
+        entityType: Any,
+        fieldName: str,
+        value: Any,
+        errorMessage: Optional[str] = None,
+    ):
+        if isinstance(entityType, object):
+            t = type(entityType).__name__
+        elif isinstance(entityType, type) and issubclass(entityType, Entity):
+            t = entityType.__name__
+
+        m = f"Illegal value for field '{t}.{fieldName} = {value}'"
+        if errorMessage:
+            m += ":" + errorMessage
+        super().__init__(m)
+
+
+class UnfinishedConversionException(LOGSException):
+    def __init__(self, conversion: "Conversion"):
+        super().__init__(
+            f"Conversion for dataset {conversion.datasetId} from format '{conversion.datasetFormat}' to format '{conversion.exportFormat}' is not finished yet."
+        )

LOGS/Auxiliary/LOGSErrorResponse.py

@@ -0,0 +1,89 @@
+from enum import Enum
+from typing import Dict, Generic, List, Optional, Union
+
+from typing_extensions import TypeVar
+
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Entity.SerializableContent import SerializableClass
+
+
+class LogsErrorType(Enum):
+    EntityList = "EntityList"
+    ParameterValidation = "ParameterValidation"
+
+
+class ILogsErrorClass(SerializableClass):
+    pass
+
+
+_T = TypeVar("_T", bound=ILogsErrorClass)
+_idType = TypeVar("_idType", bound=Union[int, str])
+
+
+class EntityListErrorClass(Generic[_idType], ILogsErrorClass):
+    ids: List[_idType] = []
+    errors: List[str] = []
+
+
+class LOGSErrorResponse(Generic[_T], SerializableClass):
+    _noSerialize = ["errorStringList", "details"]
+
+    header: Optional[str] = None
+    title: Optional[str] = None
+    status: Optional[int] = None
+    errorsType: Optional[LogsErrorType] = None
+    errorsClass: Optional[Dict] = None
+    errors: Optional[Union[Dict, List]] = None
+    details: Optional[str] = None
+
+    def _fieldToStr(self, d: Union[Dict, List], indentation: int = 0) -> List[str]:
+        tab = self._indentationString * indentation
+
+        if isinstance(d, list):
+            s = []
+            for v in d:
+                s.extend(self._fieldToStr(v, indentation))
+            return s
+        elif isinstance(d, dict):
+            s = []
+            nextTab = tab + self._indentationString
+            for k, v in d.items():
+                l = self._fieldToStr(v)
+                if l is None:
+                    continue
+                if len(l) < 1:
+                    s.append(f"{tab}{k}: <empty>")
+                if len(l) > 1:
+                    s.append(f"{tab}{k}:")
+                    s.extend([f"{nextTab}{i}" for i in l])
+                else:
+                    s.append(f"{tab}{k}: {l[0]}")
+
+            return s
+
+        if d is None:
+            return None
+        return [str(d)]
+
+    def __str__(self):
+        s1 = f":{self.status}" if self.status else ""
+        s2 = f"'{Tools.truncString(self.title, 50)}'" if self.title else ""
+        return f"<{type(self).__name__}{s1} {s2}>"
+
+    def errorString(self, prefix: str = "") -> str:
+        return "\n".join(f"{prefix}{f}" for f in self.errorStringList)
+
+    @property
+    def errorStringList(self) -> List[str]:
+        errors: List[str] = []
+
+        if self.title:
+            errors.append(str(self.title))
+        elif self.header:
+            errors.append(str(self.header))
+
+        if self.errors:
+            errors.append(f"{self._indentationString}Details:")
+            errors.extend(self._fieldToStr(self.errors, 2))
+
+        return errors

LOGS/Auxiliary/MinimalModelGenerator.py

@@ -0,0 +1,236 @@
+from typing import TYPE_CHECKING, Any, Optional, Type
+
+if TYPE_CHECKING:
+    from LOGS.LOGSConnection import LOGSConnection
+
+
+class MinimalModelGenerator:
+    _entities = [
+        "Attachment",
+        "Bridge",
+        "Dataset",
+        "DataFormatInstrument",
+        "Method",
+        "DataFormat",
+        "Vendor",
+        "Notebook",
+        "NotebookExperiment",
+        "NotebookEntry",
+        "NotebookTemplate",
+        "LabNotebook",
+        "LabNotebookExperiment",
+        "LabNotebookEntry",
+        "Origin",
+        "Person",
+        "Project",
+        "Sample",
+        "SharedContent",
+        "InventoryItem",
+        "CustomType",
+        "CustomField",
+    ]
+
+    @classmethod
+    def createMapper(cls):
+        cls._mapper = {e: getattr(cls, f"get{e}MinimalClass")() for e in cls._entities}
+        cls._mapper.update({f"{e}Minimal": cls._mapper[e] for e in cls._entities})
+
+    @classmethod
+    def _typeByTypename(cls, typeName: str, fieldName: Optional[str]) -> Type:
+        if not hasattr(cls, "_mapper"):
+            cls.createMapper()
+
+        t = cls._mapper.get(typeName, None)
+        if not t:
+            raise ValueError(f"Unknown type '{typeName}' for field '{fieldName}'")
+        return t
+
+    @classmethod
+    def MinimalFromSingle(
+        cls,
+        value: Any,
+        fieldType: str,
+        fieldName: Optional[str],
+        connection: Optional["LOGSConnection"],
+    ) -> Any:
+        from LOGS.Entity.ConnectedEntity import ConnectedEntity
+
+        result = ConnectedEntity.checkAndConvertWithConnection(
+            value,
+            fieldType=cls._typeByTypename(fieldType, fieldName),
+            fieldName=fieldName,
+            allowNone=True,
+            connection=connection,
+        )
+
+        return result
+
+    @classmethod
+    def MinimalFromList(
+        cls,
+        value: Any,
+        fieldType: str,
+        fieldName: Optional[str],
+        connection: Optional["LOGSConnection"],
+    ) -> Any:
+        from LOGS.Entity.ConnectedEntity import ConnectedEntity
+
+        if isinstance(value, (int, str)):
+            value = {"id": value}
+
+        if isinstance(value, list):
+            l = []
+            for v in value:
+                if isinstance(v, (int, str)):
+                    l.append({"id": v})
+                else:
+                    l.append(v)
+            value = l
+
+        l = ConnectedEntity.checkListAndConvertWithConnection(
+            value,
+            fieldType=cls._typeByTypename(fieldType, fieldName),
+            fieldName=fieldName,
+            allowNone=True,
+            connection=connection,
+        )
+        result = [a for a in l if a]
+
+        if len(result) < 1:
+            return None
+
+        return result
+
+    @classmethod
+    def getAttachmentMinimalClass(cls):
+        from LOGS.Entities.AttachmentMinimal import AttachmentMinimal
+
+        return AttachmentMinimal
+
+    @classmethod
+    def getBridgeMinimalClass(cls):
+        from LOGS.Entities.BridgeMinimal import BridgeMinimal
+
+        return BridgeMinimal
+
+    @classmethod
+    def getDatasetMinimalClass(cls):
+        from LOGS.Entities.DatasetMinimal import DatasetMinimal
+
+        return DatasetMinimal
+
+    @classmethod
+    def getDataFormatInstrumentMinimalClass(cls):
+        from LOGS.Entities.DataFormatInstrumentMinimal import (
+            DataFormatInstrumentMinimal,
+        )
+
+        return DataFormatInstrumentMinimal
+
+    @classmethod
+    def getMethodMinimalClass(cls):
+        from LOGS.Entities.MethodMinimal import MethodMinimal
+
+        return MethodMinimal
+
+    @classmethod
+    def getDataFormatMinimalClass(cls):
+        from LOGS.Entities.DataFormatMinimal import DataFormatMinimal
+
+        return DataFormatMinimal
+
+    @classmethod
+    def getVendorMinimalClass(cls):
+        from LOGS.Entities.VendorMinimal import VendorMinimal
+
+        return VendorMinimal
+
+    @classmethod
+    def getNotebookMinimalClass(cls):
+        return cls.getLabNotebookMinimalClass()
+
+    @classmethod
+    def getLabNotebookMinimalClass(cls):
+        from LOGS.Entities.LabNotebookMinimal import LabNotebookMinimal
+
+        return LabNotebookMinimal
+
+    @classmethod
+    def getNotebookExperimentMinimalClass(cls):
+        return cls.getLabNotebookExperimentMinimalClass()
+
+    @classmethod
+    def getLabNotebookExperimentMinimalClass(cls):
+        from LOGS.Entities.LabNotebookExperimentMinimal import (
+            LabNotebookExperimentMinimal,
+        )
+
+        return LabNotebookExperimentMinimal
+
+    @classmethod
+    def getNotebookEntryMinimalClass(cls):
+        return cls.getLabNotebookEntryMinimalClass()
+
+    @classmethod
+    def getLabNotebookEntryMinimalClass(cls):
+        from LOGS.Entities.LabNotebookEntryMinimal import LabNotebookEntryMinimal
+
+        return LabNotebookEntryMinimal
+
+    @classmethod
+    def getNotebookTemplateMinimalClass(cls):
+        return cls.getLabNotebookTemplateMinimalClass()
+
+    @classmethod
+    def getLabNotebookTemplateMinimalClass(cls):
+        from LOGS.Entities.LabNotebookTemplateMinimal import LabNotebookTemplateMinimal
+
+        return LabNotebookTemplateMinimal
+
+    @classmethod
+    def getOriginMinimalClass(cls):
+        from LOGS.Entities.OriginMinimal import OriginMinimal
+
+        return OriginMinimal
+
+    @classmethod
+    def getPersonMinimalClass(cls):
+        from LOGS.Entities.PersonMinimal import PersonMinimal
+
+        return PersonMinimal
+
+    @classmethod
+    def getProjectMinimalClass(cls):
+        from LOGS.Entities.ProjectMinimal import ProjectMinimal
+
+        return ProjectMinimal
+
+    @classmethod
+    def getSampleMinimalClass(cls):
+        from LOGS.Entities.SampleMinimal import SampleMinimal
+
+        return SampleMinimal
+
+    @classmethod
+    def getSharedContentMinimalClass(cls):
+        from LOGS.Entities.SharedContentMinimal import SharedContentMinimal
+
+        return SharedContentMinimal
+
+    @classmethod
+    def getInventoryItemMinimalClass(cls):
+        from LOGS.Entities.InventoryItemMinimal import InventoryItemMinimal
+
+        return InventoryItemMinimal
+
+    @classmethod
+    def getCustomTypeMinimalClass(cls):
+        from LOGS.Entities.CustomTypeMinimal import CustomTypeMinimal
+
+        return CustomTypeMinimal
+
+    @classmethod
+    def getCustomFieldMinimalClass(cls):
+        from LOGS.Entities.CustomFieldMinimal import CustomFieldMinimal
+
+        return CustomFieldMinimal