logs-py 1.13__py3-none-any.whl → 2.1__py3-none-any.whl

LOGS/Entities/ExperimentRelations.py

@@ -0,0 +1,23 @@
+from typing import TYPE_CHECKING, Optional
+
+from LOGS.Entity.EntityRelation import EntityRelation
+from LOGS.Entity.EntityRelations import EntityRelations
+
+if TYPE_CHECKING:
+    from LOGS.Entities.Dataset import Dataset
+
+
+class ExperimentRelations(EntityRelations):
+    """Relations of a Experiment with other entities"""
+
+    _datasets: Optional[EntityRelation["Dataset"]] = None
+
+    @property
+    def datasets(self) -> Optional[EntityRelation["Dataset"]]:
+        return self._datasets
+
+    @datasets.setter
+    def datasets(self, value):
+        from LOGS.Entities.Datasets import Datasets
+
+        self._datasets = self._entityConverter(value, Datasets)

LOGS/Entities/ExperimentRequestParameter.py

@@ -1,11 +1,36 @@
 from dataclasses import dataclass
+from enum import Enum
 from typing import List, Optional
 
+from LOGS.Entities.IRelatedEntityRequest import IRelatedEntityRequest
 from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
-from LOGS.Interfaces.IOwnedEntity import IOwnedEntityRequest
+from LOGS.Interfaces.ICreationRecord import ICreationRecordRequest
+from LOGS.Interfaces.IModificationRecord import IModificationRecordRequest
+
+
+class ExperimentOrder(Enum):
+    ID_ASC = "ID_ASC"
+    ID_DESC = "ID_DESC"
+    NAME_ASC = "NAME_ASC"
+    NAME_DESC = "NAME_DESC"
+    METHOD_ASC = "METHOD_ASC"
+    METHOD_DESC = "METHOD_DESC"
+    CREATED_ON_ASC = "CREATED_ON_ASC"
+    CREATED_ON_DESC = "CREATED_ON_DESC"
+    CREATED_BY_ASC = "CREATED_BY_ASC"
+    CREATED_BY_DESC = "CREATED_BY_DESC"
+    MODIFIED_ON_ASC = "MODIFIED_ON_ASC"
+    MODIFIED_ON_DESC = "MODIFIED_ON_DESC"
+    MODIFIED_BY_ASC = "MODIFIED_BY_ASC"
+    MODIFIED_BY_DESC = "MODIFIED_BY_DESC"
 
 
 @dataclass
-class ExperimentRequestParameter(EntityRequestParameter, IOwnedEntityRequest):
+class ExperimentRequestParameter(
+    EntityRequestParameter[ExperimentOrder],
+    IRelatedEntityRequest,
+    ICreationRecordRequest,
+    IModificationRecordRequest,
+):
     name: Optional[str] = None
     methodIds: Optional[List[int]] = None

LOGS/Entities/Format.py

@@ -9,10 +9,10 @@ from LOGS.LOGSConnection import LOGSConnection
 
 @Endpoint("parsers")
 class Format(INamedEntity, EntityWithStrId):
-    _version: str
+    _formatVersion: str
     _vendors: List[str]
-    _methods: List[str]
-    _formats: List[str]
+    _method: List[str]
+    _format: List[str]
     _instruments: List[str]
     _metaData: List[FormatMetaData]
 
@@ -24,80 +24,46 @@ class Format(INamedEntity, EntityWithStrId):
     ):
         """Represents a connected LOGS entity type"""
 
-        self._version = "0.0"
-        self._vendors = []
-        self._methods = []
-        self._formats = []
+        self._formatVersion = "0.0"
+        self._vendor = []
+        self._method = []
+        self._format = []
         self._instruments = []
         self._metaData = []
 
         super().__init__(ref=ref, id=id, connection=connection)
 
-    def fromDict(self, ref, formatDict=None) -> None:
-        if isinstance(ref, dict):
-            if "metaData" in ref and isinstance(ref["metaData"], list):
-                ref["vendors"] = []
-                ref["methods"] = []
-                ref["instruments"] = []
-                ref["formats"] = []
-                for metaData in ref["metaData"]:
-                    if metaData["vendor"]:
-                        ref["vendors"].extend(v["name"] for v in metaData["vendor"])
-                    if metaData["method"]:
-                        ref["methods"].extend(v["name"] for v in metaData["method"])
-                    if metaData["instrument"]:
-                        ref["instruments"].extend(
-                            v["name"] for v in metaData["instrument"]
-                        )
-                    if metaData["format"]:
-                        ref["formats"].extend(v["name"] for v in metaData["format"])
-
-            if "majorVersion" in ref and "minorVersion" in ref:
-                ref["version"] = "%s.%s" % (ref["majorVersion"], ref["minorVersion"])
-        super().fromDict(ref=ref, formatDict=formatDict)
-
-    def toDict(self):
-        d = super().toDict()
-
-        if self.version:
-            d["majorVersion"], d["minorVersion"] = [
-                int(v) for v in self.version.split(".")
-            ]
-            del d["version"]
-
-        return d
-
     @property
-    def version(self) -> Optional[str]:
-        return self._version
+    def formatVersion(self) -> Optional[str]:
+        return self._formatVersion
 
-    @version.setter
-    def version(self, value):
-        self._version = self.checkAndConvert(value, str, "version")
+    @formatVersion.setter
+    def formatVersion(self, value):
+        self._formatVersion = self.checkAndConvert(value, str, "formatVersion")
 
     @property
-    def vendors(self) -> List[str]:
-        return self._vendors
+    def vendor(self) -> List[str]:
+        return self._vendor
 
-    @vendors.setter
-    def vendors(self, value):
-        self._vendors = self.checkListAndConvert(value, str, "vendors")
+    @vendor.setter
+    def vendor(self, value):
+        self._vendor = self.checkListAndConvert(value, str, "vendor")
 
     @property
-    def methods(self) -> List[str]:
-        return self._methods
+    def method(self) -> List[str]:
+        return self._method
 
-    @methods.setter
-    def methods(self, value):
-        self._methods = self.checkListAndConvert(value, str, "methods")
+    @method.setter
+    def method(self, value):
+        self._method = self.checkListAndConvert(value, str, "method")
 
     @property
-    def formats(self) -> List[str]:
-        return self._formats
+    def format(self) -> List[str]:
+        return self._format
 
-    @formats.setter
-    def formats(self, value):
-        self._formats = self.checkListAndConvert(value, str, "formats")
+    @format.setter
+    def format(self, value):
+        self._format = self.checkListAndConvert(value, str, "format")
 
     @property
     def instruments(self) -> List[str]:

LOGS/Entities/FormatFormat.py

@@ -8,7 +8,7 @@ from LOGS.Interfaces.INamedEntity import INamedEntity
 @Endpoint("formats")
 class FormatFormat(INamedEntity, EntityWithStrId):
     _description: Optional[str]
-    _version: Optional[List[str]]
+    _formatVersion: Optional[List[str]]
 
     @property
     def description(self) -> Optional[str]:
@@ -19,9 +19,11 @@ class FormatFormat(INamedEntity, EntityWithStrId):
         self._description = self.checkAndConvertNullable(value, str, "description")
 
     @property
-    def version(self) -> Optional[List[str]]:
-        return self._version
+    def formatVersion(self) -> Optional[List[str]]:
+        return self._formatVersion
 
-    @version.setter
-    def version(self, value):
-        self._version = self.checkListAndConvertNullable(value, str, "version")
+    @formatVersion.setter
+    def formatVersion(self, value):
+        self._formatVersion = self.checkListAndConvertNullable(
+            value, str, "formatVersion"
+        )

LOGS/Entities/FormatInstrument.py

@@ -6,8 +6,8 @@ from LOGS.Interfaces.INamedEntity import INamedEntity
 
 
 @Endpoint("parser_instruments")
-class FormatInstrument(INamedEntity, EntityWithStrId):
-    _description: Optional[str]
+class FormatInstrument(EntityWithStrId, INamedEntity):
+    _description: Optional[str] = None
 
     @property
     def description(self) -> Optional[str]:

LOGS/Entities/FormatMetaData.py

@@ -1,7 +1,8 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, List, Optional
 
 from LOGS.Auxiliary.MinimalModelGenerator import MinimalFromList
 from LOGS.Entity.ConnectedEntity import ConnectedEntity
+from LOGS.LOGSConnection import LOGSConnection
 
 if TYPE_CHECKING:
     from LOGS.Entities.FormatFormatMinimal import FormatFormatMinimal
@@ -11,10 +12,17 @@ if TYPE_CHECKING:
 
 
 class FormatMetaData(ConnectedEntity):
-    _vendor: List["FormatVendorMinimal"] = []
-    _method: List["FormatMethodMinimal"] = []
-    _format: List["FormatFormatMinimal"] = []
-    _instrument: List["FormatInstrumentMinimal"] = []
+    _vendor: List["FormatVendorMinimal"]
+    _method: List["FormatMethodMinimal"]
+    _format: List["FormatFormatMinimal"]
+    _instrument: List["FormatInstrumentMinimal"]
+
+    def __init__(self, ref=None, connection: Optional[LOGSConnection] = None):
+        self._vendor = []
+        self._method = []
+        self._format = []
+        self._instrument = []
+        super().__init__(ref=ref, connection=connection)
 
     @property
     def vendor(self) -> List["FormatVendorMinimal"]:

LOGS/Entities/FormatMethod.py

@@ -1,17 +1,38 @@
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, List, Optional
 
 from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalFromList
 from LOGS.Entity.EntityWithStrId import EntityWithStrId
 from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.LOGSConnection import LOGSConnection
 
 if TYPE_CHECKING:
-    pass
+    from LOGS.Entities.FormatMethodMinimal import FormatMethodMinimal
 
 
 @Endpoint("parser_methods")
-class FormatMethod(INamedEntity, EntityWithStrId):
+class FormatMethod(EntityWithStrId, INamedEntity):
     _fullName: Optional[str]
     _description: Optional[str]
+    _parent: Optional[List["FormatMethodMinimal"]]
+
+    def __init__(
+        self,
+        ref=None,
+        id: Optional[str] = None,
+        connection: Optional[LOGSConnection] = None,
+    ):
+        self._fullName = None
+        self._description = None
+        self._parent = None
+
+        super().__init__(ref=ref, id=id, connection=connection)
+
+    def fromDict(self, ref, formatDict=None) -> None:
+        if isinstance(ref, dict) and "from" in ref:
+            ref["parent"] = ref["from"]
+
+        super().fromDict(ref=ref, formatDict=formatDict)
 
     @property
     def fullName(self) -> Optional[str]:
@@ -28,3 +49,13 @@ class FormatMethod(INamedEntity, EntityWithStrId):
     @description.setter
     def description(self, value):
         self._description = self.checkAndConvertNullable(value, str, "description")
+
+    @property
+    def parent(self) -> Optional[List["FormatMethodMinimal"]]:
+        return self._parent
+
+    @parent.setter
+    def parent(self, value):
+        self._parent = MinimalFromList(
+            value, "FormatMethodMinimal", "parent", connection=self.connection
+        )

LOGS/Entities/FormatMinimal.py

@@ -1,3 +1,5 @@
+from typing import List, Optional
+
 from LOGS.Auxiliary.Decorators import FullModel
 from LOGS.Entities.Format import Format
 from LOGS.Entity.EntityMinimalWithStrId import EntityMinimalWithStrId
@@ -5,4 +7,12 @@ from LOGS.Entity.EntityMinimalWithStrId import EntityMinimalWithStrId
 
 @FullModel(Format)
 class FormatMinimal(EntityMinimalWithStrId[Format]):
-    pass
+    _version: Optional[List[str]] = None
+
+    @property
+    def version(self) -> Optional[List[str]]:
+        return self._version
+
+    @version.setter
+    def version(self, value):
+        self._version = self.checkListAndConvertNullable(value, str, "version")

LOGS/Entities/FormatRequestParameter.py

@@ -1,9 +1,14 @@
 from dataclasses import dataclass
-from typing import Optional
+from typing import List, Optional
 
-from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Entity.EntityRequestParameter import DefaultOrder, EntityRequestParameter
 
 
 @dataclass
-class FormatRequestParameter(EntityRequestParameter):
+class FormatRequestParameter(EntityRequestParameter[DefaultOrder]):
     name: Optional[str] = None
+    vendors: Optional[List[str]] = None
+    vendors: Optional[List[str]] = None
+    methods: Optional[List[str]] = None
+    formats: Optional[List[str]] = None
+    instruments: Optional[List[str]] = None

LOGS/Entities/FormatVendor.py

@@ -3,13 +3,26 @@ from typing import Optional
 from LOGS.Auxiliary.Decorators import Endpoint
 from LOGS.Entity.EntityWithStrId import EntityWithStrId
 from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.LOGSConnection import LOGSConnection
 
 
 @Endpoint("vendors")
-class FormatVendor(INamedEntity, EntityWithStrId):
+class FormatVendor(EntityWithStrId, INamedEntity):
     _description: Optional[str]
     _icon: Optional[str]
 
+    def __init__(
+        self,
+        ref=None,
+        id: Optional[str] = None,
+        connection: Optional[LOGSConnection] = None,
+    ):
+        """Represents a connected LOGS entity type"""
+
+        self._description = None
+        self._icon = None
+        super().__init__(ref=ref, id=id, connection=connection)
+
     @property
     def description(self) -> Optional[str]:
         return self._description

LOGS/Entities/FormatVendorRequestParameter.py

@@ -6,4 +6,5 @@ from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
 
 @dataclass
 class FormatVendorRequestParameter(EntityRequestParameter):
+    name: Optional[str] = None
     includeIcon: Optional[bool] = None

LOGS/Entities/ICustomSchemaRequest.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+@dataclass
+class ICustomSchemaRequest:
+    typeIds: Optional[List[str]] = None

LOGS/Entities/IRelatedEntityRequest.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class IRelatedEntityRequest:
+    includeRelations: Optional[bool] = None
+    includeRelationLink: Optional[bool] = None
+    includeRelationCount: Optional[bool] = None

LOGS/Entities/Instrument.py

@@ -2,16 +2,30 @@ from typing import Optional
 
 from LOGS.Auxiliary.Decorators import Endpoint
 from LOGS.Auxiliary.MinimalModelGenerator import MethodMinimalFromDict
+from LOGS.Entities.InstrumentRelations import InstrumentRelations
 from LOGS.Entities.MethodMinimal import MethodMinimal
-from LOGS.Entity.EntityWithIntId import EntityWithIntId
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
+from LOGS.Interfaces.ICreationRecord import ICreatedOn
+from LOGS.Interfaces.IModificationRecord import IModifiedOn
 from LOGS.Interfaces.INamedEntity import INamedEntity
 from LOGS.Interfaces.IOwnedEntity import IOwnedEntity
+from LOGS.Interfaces.IRelatedEntity import IRelatedEntity
 from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
 from LOGS.LOGSConnection import LOGSConnection
 
 
 @Endpoint("instruments")
-class Instrument(INamedEntity, EntityWithIntId, IUniqueEntity, IOwnedEntity):
+class Instrument(
+    IEntityWithIntId,
+    IRelatedEntity[InstrumentRelations],
+    INamedEntity,
+    IOwnedEntity,
+    IUniqueEntity,
+    ICreatedOn,
+    IModifiedOn,
+):
+    _relationType = type(InstrumentRelations)
+
     _serialnumber: Optional[str]
     _room: Optional[str]
     _notes: Optional[str]

LOGS/Entities/InstrumentRelations.py

@@ -0,0 +1,23 @@
+from typing import TYPE_CHECKING, Optional
+
+from LOGS.Entity.EntityRelation import EntityRelation
+from LOGS.Entity.EntityRelations import EntityRelations
+
+if TYPE_CHECKING:
+    from LOGS.Entities.Dataset import Dataset
+
+
+class InstrumentRelations(EntityRelations):
+    """Relations of a Instrument with other entities"""
+
+    _datasets: Optional[EntityRelation["Dataset"]] = None
+
+    @property
+    def datasets(self) -> Optional[EntityRelation["Dataset"]]:
+        return self._datasets
+
+    @datasets.setter
+    def datasets(self, value):
+        from LOGS.Entities.Datasets import Datasets
+
+        self._datasets = self._entityConverter(value, Datasets)

LOGS/Entities/InstrumentRequestParameter.py

@@ -1,9 +1,41 @@
 from dataclasses import dataclass
-from typing import Optional
+from enum import Enum
+from typing import List, Optional
 
+from LOGS.Entities.IRelatedEntityRequest import IRelatedEntityRequest
 from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Interfaces.ICreationRecord import ICreatedOnRequest
+from LOGS.Interfaces.IModificationRecord import IModifiedOnRequest
+from LOGS.Interfaces.IOwnedEntity import IOwnedEntityRequest
+
+
+class InstrumentOrder(Enum):
+    ID_ASC = "ID_ASC"
+    ID_DESC = "ID_DESC"
+    NAME_ASC = "NAME_ASC"
+    NAME_DESC = "NAME_DESC"
+    METHOD_ASC = "METHOD_ASC"
+    METHOD_DESC = "METHOD_DESC"
+    CREATED_ON_ASC = "CREATED_ON_ASC"
+    CREATED_ON_DESC = "CREATED_ON_DESC"
+    CREATED_BY_ASC = "CREATED_BY_ASC"
+    CREATED_BY_DESC = "CREATED_BY_DESC"
+    MODIFIED_ON_ASC = "MODIFIED_ON_ASC"
+    MODIFIED_ON_DESC = "MODIFIED_ON_DESC"
+    MODIFIED_BY_ASC = "MODIFIED_BY_ASC"
+    MODIFIED_BY_DESC = "MODIFIED_BY_DESC"
+    IS_OBSOLETE_ASC = "IS_OBSOLETE_ASC"
+    IS_OBSOLETE_DESC = "IS_OBSOLETE_DESC"
 
 
 @dataclass
-class InstrumentRequestParameter(EntityRequestParameter):
+class InstrumentRequestParameter(
+    EntityRequestParameter[InstrumentOrder],
+    IRelatedEntityRequest,
+    ICreatedOnRequest,
+    IModifiedOnRequest,
+    IOwnedEntityRequest,
+):
     name: Optional[str] = None
+    methodIds: Optional[List[int]] = None
+    datasetIds: Optional[List[int]] = None

LOGS/Entities/LabNotebookEntry.py

@@ -2,22 +2,46 @@ from datetime import datetime
 from typing import Optional
 
 from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.LabNotebookEntryRelations import LabNotebookEntryRelations
 from LOGS.Entity.EntityMinimalWithIntId import EntityMinimalWithIntId
-from LOGS.Entity.EntityWithIntId import EntityWithIntId
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
 from LOGS.Interfaces.ICreationRecord import ICreationRecord
 from LOGS.Interfaces.IModificationRecord import IModificationRecord
 from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.Interfaces.IRelatedEntity import IRelatedEntity
+from LOGS.Interfaces.ISoftDeletable import ISoftDeletable
+from LOGS.LOGSConnection import LOGSConnection
 
 
 @Endpoint("lab_notebook_entries")
 class LabNotebookEntry(
-    INamedEntity, EntityWithIntId, ICreationRecord, IModificationRecord
+    IEntityWithIntId,
+    IRelatedEntity[LabNotebookEntryRelations],
+    INamedEntity,
+    ICreationRecord,
+    IModificationRecord,
+    ISoftDeletable,
 ):
-    _version: Optional[int] = None
-    _labNotebook: Optional[EntityMinimalWithIntId] = None
-    _labNotebookExperiment: Optional[EntityMinimalWithIntId] = None
-    _entryDate: Optional[datetime] = None
-    _isDeleted: Optional[bool] = None
+    _relationType = type(LabNotebookEntryRelations)
+
+    _version: Optional[int]
+    _labNotebook: Optional[EntityMinimalWithIntId]
+    _labNotebookExperiment: Optional[EntityMinimalWithIntId]
+    _entryDate: Optional[datetime]
+
+    def __init__(
+        self,
+        ref=None,
+        id: Optional[int] = None,
+        connection: Optional[LOGSConnection] = None,
+    ):
+        """Represents a connected LOGS entity type"""
+        self._version = None
+        self._labNotebook = None
+        self._labNotebookExperiment = None
+        self._entryDate = None
+
+        super().__init__(ref=ref, id=id, connection=connection)
 
     def fromDict(self, ref, formatDict=None) -> None:
         if isinstance(ref, dict):
@@ -25,3 +49,39 @@ class LabNotebookEntry(
                 ref["name"] = ref["name"].replace(" > ", "_")
 
         super().fromDict(ref, formatDict)
+
+    @property
+    def version(self) -> Optional[int]:
+        return self._version
+
+    @version.setter
+    def version(self, value):
+        self._version = self.checkAndConvertNullable(value, int, "version")
+
+    @property
+    def labNotebook(self) -> Optional[EntityMinimalWithIntId]:
+        return self._labNotebook
+
+    @labNotebook.setter
+    def labNotebook(self, value):
+        self._labNotebook = self.checkAndConvertNullable(
+            value, EntityMinimalWithIntId, "labNotebook"
+        )
+
+    @property
+    def labNotebookExperiment(self) -> Optional[EntityMinimalWithIntId]:
+        return self._labNotebookExperiment
+
+    @labNotebookExperiment.setter
+    def labNotebookExperiment(self, value):
+        self._labNotebookExperiment = self.checkAndConvertNullable(
+            value, EntityMinimalWithIntId, "labNotebookExperiment"
+        )
+
+    @property
+    def entryDate(self) -> Optional[datetime]:
+        return self._entryDate
+
+    @entryDate.setter
+    def entryDate(self, value):
+        self._entryDate = self.checkAndConvertNullable(value, datetime, "entryDate")