logs-py 2.9.6__py3-none-any.whl → 3.0.1__py3-none-any.whl

LOGS/Auxiliary/DateTimeConverter.py

@@ -1,7 +1,10 @@
 import datetime as dt
 import re
+import time
 from typing import List, cast
 
+import pytz
+
 
 class DateTimeConverter:
     # When adding pattern here put the pattern with most information on top
@@ -22,5 +25,12 @@ class DateTimeConverter:
                 dates.append(dt.datetime.strptime(entry, pattern))
             except:
                 continue
+        if len(dates) < 1:
+            return None
+
+        d = dates[0]
+        if d.tzinfo == pytz.UTC or d.tzinfo is None:
+            local_tz = pytz.timezone(time.tzname[0])  # Change to your local timezone
+            d = d.replace(tzinfo=pytz.utc).astimezone(local_tz)
 
-        return dates[0] if len(dates) > 0 else None
+        return d

LOGS/Auxiliary/Exceptions.py

@@ -1,10 +1,11 @@
-from typing import TYPE_CHECKING, List, Optional, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Any, List, Optional, TypeVar, Union, cast
 
 from LOGS.Auxiliary.Constants import Constants
 from LOGS.Auxiliary.LOGSErrorResponse import LOGSErrorResponse
 from LOGS.Auxiliary.Tools import Tools
 
 if TYPE_CHECKING:
+    from LOGS.Converter.Conversion import Conversion
     from LOGS.Entity.ConnectedEntity import ConnectedEntity
     from LOGS.Entity.Entity import Entity
 
@@ -46,7 +47,7 @@ class LOGSException(Exception):
 
     def _fromResponse(self, response: LOGSErrorResponse):
         self.title = response.title
-        self.details = response.details
+        self.details = response.description
         self.status = response.status
         self.type = response.type
 
@@ -105,6 +106,7 @@ class EntityIncompleteException(LOGSException):
         parameterName: Optional[str] = None,
         functionName: Optional[str] = None,
         responseError: Optional[LOGSErrorResponse] = None,
+        hasFetchFull: bool = True,
     ):
         if not errors and responseError:
             errors = responseError.errors
@@ -115,6 +117,7 @@ class EntityIncompleteException(LOGSException):
                 errors=errors,
                 functionName=functionName,
                 parameterName=parameterName,
+                hasFetchFull=hasFetchFull,
             ),
             responseError=responseError,
         )
@@ -125,14 +128,20 @@ class EntityIncompleteException(LOGSException):
         errors: Optional[List[str]] = None,
         parameterName: Optional[str] = None,
         functionName: Optional[str] = None,
+        hasFetchFull: bool = True,
     ):
         indent = " " * 2
         message = ""
 
         name = f" '{parameterName}' " if parameterName else " "
-        func = f" '{functionName}' or all complete fetch " if functionName else " "
+        func = []
+        if functionName:
+            func.append(f"'{functionName}'")
 
-        message = f"Additional field{name}of entity was not fetched for efficiency reasons. Use{func}'fetchFull()' method to fetch this parameter"
+        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:
@@ -297,3 +306,30 @@ class EntityNotConnectedException(NotConnectedException):
             super().__init__("Entity %a is not connected." % (identifier))
         else:
             super().__init__("Entity is not connected.")
+
+
+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

@@ -3,7 +3,7 @@ from typing import Any, List, Optional, cast
 
 class LOGSErrorResponse:
     title: Optional[str] = None
-    details: Optional[str] = None
+    description: Optional[str] = None
     status: Optional[int] = None
     type: Optional[str] = None
 
@@ -27,6 +27,9 @@ class LOGSErrorResponse:
         if "title" in ref:
             errors.append(str(ref["title"]))
 
+        if "description" in ref:
+            errors.extend(str(ref["description"]).split("\n"))
+
         if "error" in ref:
             errors = [f"({str(ref['error'])})"]
 

LOGS/Auxiliary/MinimalModelGenerator.py

@@ -11,40 +11,52 @@ if TYPE_CHECKING:
 
 def _typeByTypename(fieldType):
     switcher = {
-        "BridgeMinimal": BridgeMinimalFromDict,
         "Bridge": BridgeMinimalFromDict,
-        "DatasetMinimal": DatasetMinimalFromDict,
+        "BridgeMinimal": BridgeMinimalFromDict,
+        "CustomType": CustomTypeMinimalFromDict,
+        "CustomTypeMinimal": CustomTypeMinimalFromDict,
         "Dataset": DatasetMinimalFromDict,
-        "EquipmentMinimal": EquipmentMinimalFromDict,
+        "DatasetMinimal": DatasetMinimalFromDict,
         "Equipment": EquipmentMinimalFromDict,
-        "ExperimentMinimal": ExperimentMinimalFromDict,
+        "EquipmentMinimal": EquipmentMinimalFromDict,
         "Experiment": ExperimentMinimalFromDict,
-        "InstrumentMinimal": InstrumentMinimalFromDict,
+        "ExperimentMinimal": ExperimentMinimalFromDict,
+        "FormatFormat": FormatFormatMinimalFromDict,
+        "FormatFormatMinimal": FormatFormatMinimalFromDict,
+        "Format": FormatMinimalFromDict,
+        "FormatInstrument": FormatInstrumentMinimalFromDict,
+        "FormatInstrumentMinimal": FormatInstrumentMinimalFromDict,
+        "FormatMethod": FormatMethodMinimalFromDict,
+        "FormatMethodMinimal": FormatMethodMinimalFromDict,
+        "FormatMinimal": FormatMinimalFromDict,
+        "FormatVendor": FormatVendorMinimalFromDict,
+        "FormatVendorMinimal": FormatVendorMinimalFromDict,
+        "InstrumentFacility": InstrumentMinimalFromDict,
+        "InstrumentFacilityMinimal": InstrumentMinimalFromDict,
         "Instrument": InstrumentMinimalFromDict,
-        "MethodMinimal": MethodMinimalFromDict,
+        "InstrumentMinimal": InstrumentMinimalFromDict,
+        "LabNotebook": LabNotebookMinimalFromDict,
+        "LabNotebookMinimal": LabNotebookMinimalFromDict,
+        "LabNotebookExperiment": LabNotebookExperimentMinimalFromDict,
+        "LabNotebookExperimentMinimal": LabNotebookExperimentMinimalFromDict,
+        "LabNotebookEntry": LabNotebookEntryMinimalFromDict,
+        "LabNotebookEntryMinimal": LabNotebookEntryMinimalFromDict,
         "Method": MethodMinimalFromDict,
+        "MethodMinimal": MethodMinimalFromDict,
+        "OriginMinimal": OriginMinimalFromDict,
+        "Origin": OriginMinimalFromDict,
         "PersonMinimal": PersonMinimalFromDict,
         "Person": PersonMinimalFromDict,
         "ProjectMinimal": ProjectMinimalFromDict,
         "Project": ProjectMinimalFromDict,
         "SampleMinimal": SampleMinimalFromDict,
         "Sample": SampleMinimalFromDict,
-        "LabNotebookEntry": LabNotebookEntryMinimalFromDict,
-        "LabNotebookEntryMinimal": LabNotebookEntryMinimalFromDict,
-        "Origin": OriginMinimalFromDict,
-        "OriginMinimal": OriginMinimalFromDict,
-        "InstrumentFacility": InstrumentMinimalFromDict,
-        "InstrumentFacilityMinimal": InstrumentMinimalFromDict,
-        "Format": FormatMinimalFromDict,
-        "FormatMinimal": FormatMinimalFromDict,
-        "FormatVendor": FormatVendorMinimalFromDict,
-        "FormatVendorMinimal": FormatVendorMinimalFromDict,
-        "FormatMethod": FormatMethodMinimalFromDict,
-        "FormatMethodMinimal": FormatMethodMinimalFromDict,
-        "FormatInstrument": FormatInstrumentMinimalFromDict,
-        "FormatInstrumentMinimal": FormatInstrumentMinimalFromDict,
-        "FormatFormat": FormatFormatMinimalFromDict,
-        "FormatFormatMinimal": FormatFormatMinimalFromDict,
+        "InventoryMinimal": InventoryMinimalFromDict,
+        "Inventory": InventoryMinimalFromDict,
+        "CustomTypeMinimal": CustomTypeMinimalFromDict,
+        "CustomType": CustomTypeMinimalFromDict,
+        "CustomFieldMinimal": CustomFieldMinimalFromDict,
+        "CustomField": CustomFieldMinimalFromDict,
     }
     return switcher.get(fieldType, lambda ref: None)
 
@@ -157,6 +169,38 @@ def BridgeMinimalFromDict(
     )
 
 
+def CustomTypeMinimalFromDict(
+    ref: Optional[Union[dict, Constants.ID_TYPE]],
+    fieldName: Optional[str] = None,
+    connection: Optional["LOGSConnection"] = None,
+):
+    from LOGS.Entities.CustomTypeMinimal import CustomTypeMinimal
+
+    return _checkAndConvert(
+        ref,
+        CustomTypeMinimal,
+        fieldName=fieldName,
+        allowNone=True,
+        connection=connection,
+    )
+
+
+def CustomFieldMinimalFromDict(
+    ref: Optional[Union[dict, Constants.ID_TYPE]],
+    fieldName: Optional[str] = None,
+    connection: Optional["LOGSConnection"] = None,
+):
+    from LOGS.Entities.CustomFieldMinimal import CustomFieldMinimal
+
+    return _checkAndConvert(
+        ref,
+        CustomFieldMinimal,
+        fieldName=fieldName,
+        allowNone=True,
+        connection=connection,
+    )
+
+
 def DatasetMinimalFromDict(
     ref: Optional[Union[dict, Constants.ID_TYPE]],
     fieldName: Optional[str] = None,
@@ -265,32 +309,48 @@ def SampleMinimalFromDict(
     )
 
 
-def DatasetTypeMinimalFromDict(
+def InventoryMinimalFromDict(
+    ref: Optional[Union[dict, Constants.ID_TYPE]],
+    fieldName: Optional[str] = None,
+    connection: Optional["LOGSConnection"] = None,
+):
+    from LOGS.Entities.InventoryMinimal import InventoryMinimal
+
+    return _checkAndConvert(
+        ref,
+        InventoryMinimal,
+        fieldName=fieldName,
+        allowNone=True,
+        connection=connection,
+    )
+
+
+def LabNotebookMinimalFromDict(
     ref: Optional[Union[dict, Constants.ID_TYPE]],
     fieldName: Optional[str] = None,
     connection: Optional["LOGSConnection"] = None,
 ):
-    from LOGS.Entities.DatasetTypeMinimal import DatasetTypeMinimal
+    from LOGS.Entities.LabNotebookMinimal import LabNotebookMinimal
 
     return _checkAndConvert(
         ref,
-        DatasetTypeMinimal,
+        LabNotebookMinimal,
         fieldName=fieldName,
         allowNone=True,
         connection=connection,
     )
 
 
-def SampleTypeMinimalFromDict(
+def LabNotebookExperimentMinimalFromDict(
     ref: Optional[Union[dict, Constants.ID_TYPE]],
     fieldName: Optional[str] = None,
     connection: Optional["LOGSConnection"] = None,
 ):
-    from LOGS.Entities.SampleTypeMinimal import SampleTypeMinimal
+    from LOGS.Entities.LabNotebookExperimentMinimal import LabNotebookExperimentMinimal
 
     return _checkAndConvert(
         ref,
-        SampleTypeMinimal,
+        LabNotebookExperimentMinimal,
         fieldName=fieldName,
         allowNone=True,
         connection=connection,

LOGS/Auxiliary/Tools.py

@@ -51,6 +51,14 @@ class Tools:
     messageStrMaxLength = 25
     __byteUnits = ["", "K", "M", "G", "T", "P", "E", "Z"]
 
+    @classmethod
+    def ObjectToString(cls, obj: Any) -> str:
+        name = getattr(obj, "name") if hasattr(obj, "name") else None
+        id = getattr(obj, "id") if hasattr(obj, "id") else None
+        i = " id:'%s'" % id if id is not None else ""
+        n = " name:'%s'" % name if name is not None else ""
+        return "<%s%s%s>" % (type(obj).__name__, i, n)
+
     @classmethod
     def unbufferStdout(cls):
         unbuffered = UnbufferedStdout()
@@ -181,6 +189,9 @@ class Tools:
             return value
 
         if issubclass(cast(Type[_T], fieldType), Enum):
+            if allowNone and value == None:
+                return cast(Any, None)
+
             try:
                 enum = cast(Any, fieldType)
                 return enum(value)

LOGS/Converter/Conversion.py

@@ -0,0 +1,248 @@
+import os
+from enum import Enum
+from time import sleep, time
+from typing import Any, Callable, Dict, List, Optional, cast
+
+from LOGS.Auxiliary.Exceptions import (
+    EntityFetchingException,
+    LOGSException,
+    UnfinishedConversionException,
+)
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Converter.ConverterParameter import ParameterType
+from LOGS.Entities.ParserLog import ParserLog
+from LOGS.Entity import Entity
+from LOGS.Entity.ConnectedEntity import ConnectedEntity
+from LOGS.Entity.SerializeableContent import SerializeableClass
+from LOGS.LOGSConnection import ResponseTypes
+
+
+class ConversionState(Enum):
+    Successfull = "Successfull"
+    Failed = "Failed"
+    Waiting = "Waiting"
+
+
+class ConversionFile(SerializeableClass):
+    path: Optional[str] = None
+    size: Optional[int] = None
+
+
+class DatasetConversionZipReadModel(SerializeableClass):
+    size: Optional[int] = None
+    id: Optional[str] = None
+    url: Optional[str] = None
+
+
+class ConverterParameterEntry(SerializeableClass):
+    id: Optional[str] = None
+    value: Optional[Any] = None
+    type: Optional[ParameterType] = None
+
+
+class ConversionLogModel(ParserLog):
+    pass
+
+
+class Conversion(ConnectedEntity):
+    _datasetId: Optional[int] = None
+    _datasetFormat: Optional[str] = None
+    _exportFormat: Optional[str] = None
+    _files: Optional[List[ConversionFile]] = None
+    _logs: Optional[List[ConversionLogModel]] = None
+    _output: Optional[str] = None
+    _state: Optional[ConversionState] = None
+    _zip: Optional[DatasetConversionZipReadModel] = None
+    _inputParameters: Optional[List[ConverterParameterEntry]] = None
+
+    _payload: Dict[str, Any] = {}
+    _parentEntity: Optional[Entity] = None
+
+    def download(
+        self,
+        directory: Optional[str] = None,
+        fileName: Optional[str] = None,
+        overwrite=False,
+    ):
+        connection, _ = self._getConnectionData()
+
+        if self.state == ConversionState.Waiting:
+            raise UnfinishedConversionException(self)
+
+        if self.state == ConversionState.Failed:
+            raise LOGSException(
+                f"Conversion for dataset {self.datasetId} from format '{self.datasetFormat}' to format '{self.exportFormat}' failed. Check logs for more information."
+            )
+
+        if (
+            self.zip is None
+            or self.zip.size is None
+            or self.zip.id is None
+            or self.zip.url is None
+        ):
+            raise LOGSException(
+                f"Conversion for dataset {self.datasetId} from format '{self.datasetFormat}' to format '{self.exportFormat}' did not result in any data."
+            )
+
+        if not directory:
+            directory = os.curdir
+
+        if not fileName:
+            fileName = f"dataset_{self.datasetId}_{self.zip.id}.zip"
+
+        path = os.path.join(directory, Tools.sanitizeFileName(fileName=fileName))
+
+        if overwrite:
+            if os.path.exists(path) and not os.path.isfile(path):
+                raise LOGSException("Path %a is not a file" % path)
+        else:
+            if os.path.exists(path):
+                raise LOGSException("File %a already exists" % path)
+
+        data, responseError = connection.getUrl(
+            self.zip.url, responseType=ResponseTypes.RAW
+        )
+
+        if responseError:
+            raise LOGSException(
+                f"Could not fetch conversion result for dataset {self.datasetId} from format '{self.datasetFormat}' to format '{self.exportFormat}'.",
+                responseError=responseError,
+            )
+
+        with open(path, mode="wb") as localfile:
+            localfile.write(cast(bytes, data))
+
+        return path
+
+    def _reloadOnWaiting(self, connection, endpoint):
+        if self.state != ConversionState.Waiting:
+            return
+        data, responseError = connection.postEndpoint(endpoint, data=self._payload)
+        if responseError:
+            raise EntityFetchingException(
+                entity=self._parentEntity, responseError=responseError
+            )
+        self.fromDict(data)
+
+    def awaitResult(self):
+        connection, endpoint = self._getConnectionData()
+        if self.state != ConversionState.Waiting:
+            return
+
+        while self.state == ConversionState.Waiting:
+            sleep(0.5)
+            # print("request...")
+
+            self._reloadOnWaiting(connection, endpoint)
+
+            # print("... done", self.state)
+
+    @classmethod
+    def awaitAllResults(
+        cls,
+        conversions: List["Conversion"],
+        timeout=600,
+        stateChangeHook: Optional[Callable[[int], None]] = None,
+    ):
+        l = [c for c in conversions if c is not None]
+
+        connectionList = []
+        for i, c in enumerate(l):
+            connection, endpoint = c._getConnectionData()
+            connectionList.append((c, connection, endpoint))
+
+        count = sum(
+            [1 for c in connectionList if c[0].state != ConversionState.Waiting]
+        )
+        if stateChangeHook:
+            stateChangeHook(len(connectionList) - count)
+
+        start = time()
+        while count < len(connectionList) and time() - start < timeout:
+            oldCount = count
+            count = 0
+            for c in connectionList:
+                if c[0].state != ConversionState.Waiting:
+                    count += 1
+                    continue
+                c[0]._reloadOnWaiting(c[1], c[2])
+            if stateChangeHook and oldCount != count:
+                stateChangeHook(len(connectionList) - count)
+            # print(f"waiting for {len(connectionList) -count} jobs")
+            sleep(0.5)
+
+    @property
+    def datasetId(self) -> Optional[int]:
+        return self._datasetId
+
+    @datasetId.setter
+    def datasetId(self, value):
+        self._datasetId = self.checkAndConvertNullable(value, int, "datasetId")
+
+    @property
+    def datasetFormat(self) -> Optional[str]:
+        return self._datasetFormat
+
+    @datasetFormat.setter
+    def datasetFormat(self, value):
+        self._datasetFormat = self.checkAndConvertNullable(value, str, "datasetFormat")
+
+    @property
+    def exportFormat(self) -> Optional[str]:
+        return self._exportFormat
+
+    @exportFormat.setter
+    def exportFormat(self, value):
+        self._exportFormat = self.checkAndConvertNullable(value, str, "exportFormat")
+
+    @property
+    def files(self) -> Optional[List[ConversionFile]]:
+        return self._files
+
+    @files.setter
+    def files(self, value):
+        self._files = self.checkListAndConvertNullable(value, ConversionFile, "files")
+
+    @property
+    def logs(self) -> Optional[List[ConversionLogModel]]:
+        return self._logs
+
+    @logs.setter
+    def logs(self, value):
+        self._logs = self.checkListAndConvertNullable(value, ConversionLogModel, "logs")
+
+    @property
+    def output(self) -> Optional[str]:
+        return self._output
+
+    @output.setter
+    def output(self, value):
+        self._output = self.checkAndConvertNullable(value, str, "output")
+
+    @property
+    def state(self) -> Optional[ConversionState]:
+        return self._state
+
+    @state.setter
+    def state(self, value):
+        self._state = self.checkAndConvertNullable(value, ConversionState, "state")
+
+    @property
+    def zip(self) -> Optional[DatasetConversionZipReadModel]:
+        return self._zip
+
+    @zip.setter
+    def zip(self, value):
+        self._zip = self.checkAndConvertNullable(
+            value, DatasetConversionZipReadModel, "zip"
+        )
+
+    @property
+    def inputParameters(self) -> Optional[List[ConverterParameterEntry]]:
+        return self._inputParameters
+
+    @inputParameters.setter
+    def inputParameters(self, value):
+        self._inputParameters = self.checkListAndConvertNullable(
+            value, ConverterParameterEntry, "inputParameters"
+        )

LOGS/Converter/Converter.py

@@ -0,0 +1,96 @@
+from typing import Any, Dict, List, Optional
+
+from LOGS.Auxiliary import Tools
+from LOGS.Converter.ConverterParameter import IConverterParameter
+from LOGS.Converter.ExportParamters import ExportParamters
+from LOGS.Entity.SerializeableContent import SerializeableContent
+
+
+class Converter(SerializeableContent):
+    _formatId: Optional[str] = None
+    _exportId: Optional[str] = None
+    _version: Optional[str] = None
+    _name: Optional[str] = None
+    _id: Optional[str] = None
+    _parameters: Optional[List[IConverterParameter]] = None
+
+    def __init__(self, ref=None):
+        t = type(self)
+
+        self._noSerialize += [
+            t.parameters.fget.__name__,  # type: ignore
+        ]
+
+        super().__init__(ref)
+
+    def __str__(self):
+        return Tools.ObjectToString(self)
+
+    @property
+    def formatId(self) -> Optional[str]:
+        return self._formatId
+
+    @formatId.setter
+    def formatId(self, value):
+        self._formatId = self.checkAndConvertNullable(value, str, "formatId")
+
+    @property
+    def exportId(self) -> Optional[str]:
+        return self._exportId
+
+    @exportId.setter
+    def exportId(self, value):
+        self._exportId = self.checkAndConvertNullable(value, str, "exportId")
+
+    @property
+    def version(self) -> Optional[str]:
+        return self._version
+
+    @version.setter
+    def version(self, value):
+        self._version = self.checkAndConvertNullable(value, str, "version")
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        self._name = self.checkAndConvertNullable(value, str, "name")
+
+    @property
+    def id(self) -> Optional[str]:
+        return self._id
+
+    @id.setter
+    def id(self, value):
+        self._id = self.checkAndConvertNullable(value, str, "id")
+
+    @property
+    def requestParameter(self) -> Optional[ExportParamters]:
+        if self.parameters is None:
+            return None
+
+        p: Dict[str, Any] = {p.id: None for p in self.parameters if p.id}
+        p["_parentId"] = self.id
+        return ExportParamters(
+            ref=p,
+            types={
+                p.id: IConverterParameter.TypeMapper(p.type)
+                for p in self.parameters
+                if p.id
+            },
+        )
+
+    @property
+    def parameters(self) -> Optional[List[IConverterParameter]]:
+        return self._parameters
+
+    @parameters.setter
+    def parameters(self, value):
+        self._parameters = self.checkListAndConvertNullable(
+            value,
+            fieldType=IConverterParameter,
+            converter=IConverterParameter.GetParameterFromDict,
+            fieldName="parameters",
+        )