logs-py 2.9.5__py3-none-any.whl → 3.0.0__py3-none-any.whl

LOGS/Interfaces/IRelatedEntity.py

@@ -14,7 +14,8 @@ _Relations = TypeVar("_Relations", bound=IRelationModel)
 
 @dataclass
 class IRelatedEntity(Generic[_Relations], IEntityInterface):
-    _relationType: Optional[Type[_Relations]] = None
+    # The expression here should be _relationType: Optional[Type[_Relations]] = None, but it is not working
+    _relationType: Optional[Type] = None
     _relations: Optional[_Relations] = None
 
     @property
@@ -29,6 +30,6 @@ class IRelatedEntity(Generic[_Relations], IEntityInterface):
                 % (type(self).__name__)
             )
 
-        self._createdOn = Tools.checkAndConvert(
+        self._relations = Tools.checkAndConvert(
             value, self._relationType, "relations", allowNone=True
         )

LOGS/Interfaces/ITypedEntity.py

@@ -1,28 +1,85 @@
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import TYPE_CHECKING, List, Optional, Sequence, Union
 
 from LOGS.Auxiliary import Tools
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalFromSingle
+from LOGS.Entities.CustomFieldValue import (
+    CustomFieldValue,
+    CustomSectionValue,
+    ICustomValue,
+)
+from LOGS.Entities.CustomFieldValueConverter import CustomFieldValueConverter
 from LOGS.Interfaces.IEntityInterface import IEntityInterface
 
 if TYPE_CHECKING:
-    pass
+    from LOGS.Entities.CustomTypeMinimal import CustomTypeMinimal
 
 
 @dataclass
 class ITypedEntityRequest:
-    includeCustomFields: Optional[bool] = None
-    customFields: Optional[Dict[str, Any]] = None
+    includeCustomFields: Optional[List[bool]] = None
 
 
 class ITypedEntity(IEntityInterface):
-    _customFields: Optional[Dict[str, Any]] = None
+    _customType: Optional["CustomTypeMinimal"] = None
+    _customValues: Optional[
+        Sequence[Union["CustomFieldValue", "CustomSectionValue"]]
+    ] = None
+
+    def _customValueConverter(self, value):
+        return Tools.checkListAndConvert(
+            value, ICustomValue, "customValues", allowNone=True
+        )
 
     @property
-    def customFields(self) -> Optional[Dict[str, Any]]:
-        return self._customFields
+    def customType(self) -> Optional["CustomTypeMinimal"]:
+        return self._customType
 
-    @customFields.setter
-    def customFields(self, value):
-        self._customFields = Tools.checkAndConvert(
-            value, dict, "customFields", allowNone=True
-        )
+    @customType.setter
+    def customType(self, value):
+        self._customType = MinimalFromSingle(value, "CustomTypeMinimal", "customType")
+
+    @property
+    def customValues(
+        self,
+    ) -> Optional[
+        Union[
+            Sequence[Union["CustomFieldValue", "CustomSectionValue"]],
+            Union["CustomFieldValue", "CustomSectionValue"],
+        ]
+    ]:
+        return self._customValues
+
+    @customValues.setter
+    def customValues(self, value):
+        self._customValues = CustomFieldValueConverter.convert(value, "customValues")
+
+    def _extractCustomFieldValue(
+        self,
+        value: Union[
+            CustomFieldValue,
+            CustomSectionValue,
+            Sequence[Union[CustomFieldValue, CustomSectionValue]],
+        ],
+    ) -> List[CustomFieldValue]:
+        if isinstance(value, list):
+            result: List[CustomFieldValue] = []
+            for v in value:
+                result += self._extractCustomFieldValue(v)
+            return result
+        if isinstance(value, CustomFieldValue):
+            return [value]
+        if isinstance(value, CustomSectionValue):
+            if value.content:
+                return self._extractCustomFieldValue(value.content)
+
+        return []
+
+    @property
+    def customFieldValues(
+        self,
+    ) -> Optional[List["CustomFieldValue"]]:
+        if self.customValues == None:
+            return None
+
+        return self._extractCustomFieldValue(self.customValues)

LOGS/Interfaces/IVersionedEntity.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Generic, List, Optional, TypeVar, Union
+
+from LOGS.Auxiliary import Tools
+from LOGS.Interfaces.ICreationRecord import ICreationRecord, ICreationRecordRequest
+from LOGS.Interfaces.IModificationRecord import (
+    IModificationRecord,
+    IModificationRecordRequest,
+)
+from LOGS.Interfaces.ISoftDeletable import ISoftDeletable, ISoftDeletableRequest
+
+if TYPE_CHECKING:
+    pass
+
+_idType = TypeVar("_idType", bound=Union[int, str])
+
+
+@dataclass
+class IVersionedEntityRequest(
+    Generic[_idType],
+    ICreationRecordRequest,
+    IModificationRecordRequest,
+    ISoftDeletableRequest,
+):
+    originalIds: Optional[List[_idType]] = None
+    versionIds: Optional[List[int]] = None
+    versions: Optional[List[int]] = None
+
+
+class IVersionedEntity(ICreationRecord, IModificationRecord, ISoftDeletable):
+    _version: Optional[int] = None
+
+    @property
+    def version(self) -> Optional[int]:
+        return self._version
+
+    @version.setter
+    def version(self, value):
+        self._version = Tools.checkAndConvert(value, int, "version", allowNone=True)

LOGS/LOGS.py

@@ -2,13 +2,6 @@
 """
 A library to access the LOGS API via Python
 """
-# +---------------+-----------+--------------+-------------------------+
-# |  When         |  Version  |  Who         |  What                   |
-# +===============+===========+==============+=========================+
-# |  2021-07-16   |   0.1     |  Sina Kazemi |  First version          |
-# +---------------+-----------+--------------+-------------------------+
-# |  2021-09-18   |   1.0     |  Sina Kazemi |  First official release |
-# +---------------+-----------+--------------+-------------------------+
 
 import json
 import os
@@ -36,13 +29,15 @@ from LOGS.Auxiliary import (
     Tools,
     formatErrorMessage,
 )
-from LOGS.Entities import SampleType
 from LOGS.Entities.Bridge import Bridge
 from LOGS.Entities.BridgeRequestParameter import BridgeRequestParameter
 from LOGS.Entities.Bridges import Bridges
 from LOGS.Entities.CustomField import CustomField
 from LOGS.Entities.CustomFieldRequestParameter import CustomFieldRequestParameter
 from LOGS.Entities.CustomFields import CustomFields
+from LOGS.Entities.CustomType import CustomType
+from LOGS.Entities.CustomTypeRequestParameter import CustomTypeRequestParameter
+from LOGS.Entities.CustomTypes import CustomTypes
 from LOGS.Entities.Dataset import Dataset
 from LOGS.Entities.DatasetCreator import DatasetCreator
 from LOGS.Entities.DatasetMatching import DatasetMatching
@@ -83,11 +78,22 @@ from LOGS.Entities.FormatVendors import FormatVendors
 from LOGS.Entities.Instrument import Instrument
 from LOGS.Entities.InstrumentRequestParameter import InstrumentRequestParameter
 from LOGS.Entities.Instruments import Instruments
+from LOGS.Entities.Inventories import Inventories
+from LOGS.Entities.Inventory import Inventory
+from LOGS.Entities.InventoryRequestParameter import InventoryRequestParameter
+from LOGS.Entities.LabNotebook import LabNotebook
 from LOGS.Entities.LabNotebookEntries import LabNotebookEntries
 from LOGS.Entities.LabNotebookEntry import LabNotebookEntry
 from LOGS.Entities.LabNotebookEntryRequestParameter import (
     LabNotebookEntryRequestParameter,
 )
+from LOGS.Entities.LabNotebookExperiment import LabNotebookExperiment
+from LOGS.Entities.LabNotebookExperimentRequestParameter import (
+    LabNotebookExperimentRequestParameter,
+)
+from LOGS.Entities.LabNotebookExperiments import LabNotebookExperiments
+from LOGS.Entities.LabNotebookRequestParameter import LabNotebookRequestParameter
+from LOGS.Entities.LabNotebooks import LabNotebooks
 from LOGS.Entities.Method import Method
 from LOGS.Entities.MethodRequestParameter import MethodRequestParameter
 from LOGS.Entities.Methods import Methods
@@ -106,39 +112,41 @@ from LOGS.Entities.Roles import Roles
 from LOGS.Entities.Sample import Sample
 from LOGS.Entities.SampleRequestParameter import SampleRequestParameter
 from LOGS.Entities.Samples import Samples
-from LOGS.Entities.SampleTypeRequestParameter import SampleTypeRequestParameter
-from LOGS.Entities.SampleTypes import SampleTypes
 from LOGS.Entity import Entity, EntityIterator, IEntityWithIntId
 from LOGS.Entity.ConnectedEntity import ConnectedEntity
 from LOGS.Interfaces.ISoftDeletable import ISoftDeletable
 from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
 from LOGS.LOGSConnection import LOGSConnection
+from LOGS.LOGSOptions import LOGSOptions
 from LOGS.ServerMetaData import ServerMetaData
 
 _T = TypeVar(
     "_T",
-    Document,
-    Person,
-    Project,
-    Sample,
-    Dataset,
     Bridge,
+    CustomField,
+    CustomType,
+    Dataset,
     DataSource,
+    Document,
     Equipment,
     Experiment,
+    Format,
+    FormatFormat,
+    FormatInstrument,
+    FormatMethod,
+    FormatVendor,
+    IEntityWithIntId,
     Instrument,
-    Method,
+    Inventory,
+    LabNotebook,
     LabNotebookEntry,
-    IEntityWithIntId,
+    LabNotebookExperiment,
+    Method,
     Origin,
-    Format,
+    Person,
+    Project,
     Role,
-    FormatVendor,
-    FormatMethod,
-    FormatInstrument,
-    FormatFormat,
-    CustomField,
-    SampleType,
+    Sample,
 )
 
 
@@ -147,32 +155,36 @@ class LOGS:
 
     _connection: LOGSConnection
     _entities: List[Type] = [
-        Document,
-        Person,
-        Project,
-        Sample,
-        Dataset,
         Bridge,
+        CustomField,
+        CustomType,
+        Dataset,
         DataSource,
+        Document,
         Equipment,
         Experiment,
         Instrument,
-        Method,
+        Inventory,
+        LabNotebook,
         LabNotebookEntry,
+        LabNotebookExperiment,
+        Method,
         Origin,
-        CustomField,
-        SampleType,
+        Person,
+        Project,
+        Sample,
     ]
     _entityByName = {t.__name__: t for t in _entities}
     _defaultConfigFile: str = "logs.json"
     _currentUser: Person
+    _cacheDir: Optional[str] = None
 
     def __init__(
         self,
         url: Optional[str] = None,
         apiKey: Optional[str] = None,
         configFile: Optional[str] = None,
-        verbose: bool = False,
+        options: Optional[LOGSOptions] = None,
         verify: bool = True,
     ):
         """Checks the connection to the server on creation
@@ -185,6 +197,10 @@ class LOGS:
         :raises: Exception: The URL does not define a group.
         :raises: Exception: Server cannot be reached.
         """
+        self._options = Tools.checkAndConvert(
+            options, LOGSOptions, "options", initOnNone=True
+        )
+
         _url = url
         _apiKey = apiKey
 
@@ -212,13 +228,11 @@ class LOGS:
                 "The API key to access the server %a must be provided" % _url
             )
 
-        self.verbose = verbose
         self.promptPrefix = "LOGSAPI>"
 
         self._connection = LOGSConnection(
-            url=_url, apiKey=_apiKey, verbose=verbose, verify=verify
+            url=_url, apiKey=_apiKey, options=self._options, verify=verify
         )
-
         self._currentUser = self._fetchCurrentUser()
 
     def _fetchCurrentUser(self) -> Person:
@@ -263,8 +277,23 @@ class LOGS:
             size /= 1024.0
         return "%.1f%s%s" % (size, "Yi", suffix)
 
+    def getDatasetDir(self, dataset: Dataset):
+        if self.cacheDir:
+            if not os.path.isdir(self.cacheDir):
+                raise LOGSException(
+                    f"Specified cache directory '{self.cacheDir}' cannot be opened or is not a directory."
+                )
+
+            dataDir = os.path.join(self.cacheDir, dataset.cacheId)
+            if dataDir and not os.path.exists(dataDir):
+                os.mkdir(dataDir)
+            return dataDir
+        return None
+
     def _fetchEntity(self, entityType: Type[_T], id: Union[int, str]) -> _T:
         e = entityType(id=cast(Any, id), connection=self._connection)
+        if isinstance(e, Dataset):
+            e.cacheDir = self.getDatasetDir(e)
         e.fetch()
         return e
 
@@ -352,7 +381,8 @@ class LOGS:
                 raise EntityNotFoundException(entities[0])
 
             data, responseError = self._connection.putEndpoint(
-                entityType._endpoint + [str(entities[0].id)], data=entities[0].toDict()
+                entityType._endpoint + [str(entities[0].id)],
+                data=entities[0]._toDictWithSlack(),
             )
             if (
                 isinstance(data, dict)
@@ -364,7 +394,7 @@ class LOGS:
         else:
             data, responseError = self._connection.postEndpoint(
                 entityType._endpoint + ["bulk_edit"],
-                data=[e.toDict() for e in entities],
+                data=[e._toDictWithSlack() for e in entities],
             )
             if (
                 isinstance(data, dict)
@@ -946,6 +976,42 @@ class LOGS:
             )
         return DataSources(connection=self._connection, parameters=parameter)
 
+    def labNotebook(self, id: int) -> LabNotebook:
+        return self._fetchEntity(LabNotebook, id)
+
+    def labNotebooks(
+        self, parameter: Optional[LabNotebookRequestParameter] = None
+    ) -> LabNotebooks:
+        if parameter and not isinstance(parameter, LabNotebookRequestParameter):
+            raise LOGSException(
+                "Parameter for %s.LabNotebooks must be of type %a. (Got %a)"
+                % (
+                    type(self).__name__,
+                    LabNotebookRequestParameter.__name__,
+                    type(parameter).__name__,
+                )
+            )
+        return LabNotebooks(connection=self._connection, parameters=parameter)
+
+    def labNotebookExperiment(self, id: int) -> LabNotebookExperiment:
+        return self._fetchEntity(LabNotebookExperiment, id)
+
+    def labNotebookExperiments(
+        self, parameter: Optional[LabNotebookExperimentRequestParameter] = None
+    ) -> LabNotebookExperiments:
+        if parameter and not isinstance(
+            parameter, LabNotebookExperimentRequestParameter
+        ):
+            raise LOGSException(
+                "Parameter for %s.LabNotebookExperiments must be of type %a. (Got %a)"
+                % (
+                    type(self).__name__,
+                    LabNotebookExperimentRequestParameter.__name__,
+                    type(parameter).__name__,
+                )
+            )
+        return LabNotebookExperiments(connection=self._connection, parameters=parameter)
+
     def labNotebookEntry(self, id: int) -> LabNotebookEntry:
         return self._fetchEntity(LabNotebookEntry, id)
 
@@ -1048,22 +1114,39 @@ class LOGS:
             )
         return CustomFields(connection=self._connection, parameters=parameter)
 
-    def sampleType(self, id: str) -> SampleType:
-        return self._fetchEntity(SampleType, id)
+    def customType(self, id: int) -> CustomType:
+        return self._fetchEntity(CustomType, id)
 
-    def sampleTypes(
-        self, parameter: Optional[SampleTypeRequestParameter] = None
-    ) -> SampleTypes:
-        if parameter and not isinstance(parameter, SampleTypeRequestParameter):
+    def customTypes(
+        self, parameter: Optional[CustomTypeRequestParameter] = None
+    ) -> CustomTypes:
+        if parameter and not isinstance(parameter, CustomTypeRequestParameter):
             raise LOGSException(
-                "Parameter for %s.SampleTypes must be of type %a. (Got %a)"
+                "Parameter for %s.CustomTypes must be of type %a. (Got %a)"
                 % (
                     type(self).__name__,
-                    SampleTypeRequestParameter.__name__,
+                    CustomTypeRequestParameter.__name__,
                     type(parameter).__name__,
                 )
             )
-        return SampleTypes(connection=self._connection, parameters=parameter)
+        return CustomTypes(connection=self._connection, parameters=parameter)
+
+    def inventory(self, id: int) -> Inventory:
+        return self._fetchEntity(Inventory, id)
+
+    def inventories(
+        self, parameter: Optional[InventoryRequestParameter] = None
+    ) -> Inventories:
+        if parameter and not isinstance(parameter, InventoryRequestParameter):
+            raise LOGSException(
+                "Parameter for %s.Inventories must be of type %a. (Got %a)"
+                % (
+                    type(self).__name__,
+                    InventoryRequestParameter.__name__,
+                    type(parameter).__name__,
+                )
+            )
+        return Inventories(connection=self._connection, parameters=parameter)
 
     def entity(self, uid: str):
         return Entities(connection=self._connection).fetch(uid=uid)
@@ -1126,6 +1209,13 @@ class LOGS:
         return self._currentUser
 
     @property
+    def cacheDir(self) -> Optional[str]:
+        return self._cacheDir
+
+    @cacheDir.setter
+    def cacheDir(self, value):
+        self._cacheDir = Tools.checkAndConvert(value, str, "cacheDir")
+
     def version(self) -> Optional[str]:
         return self._connection.metadata.version
 
@@ -1142,4 +1232,6 @@ if __name__ == "__main__":
     # api_key = "8V6oQ804t2nPgGPDJIk4CuneRI5q48ERUxgEpk+YqXzX9uLuMUySycHkeXP6DefN"
     # url = "http://localhost:900/sandbox"
 
-    logs = LOGS(_url, api_key, verbose=True)
+    logs = LOGS(
+        _url, api_key, options=LOGSOptions(showRequestUrl=True, showRequestBody=False)
+    )

LOGS/LOGSConnection.py

@@ -1,4 +1,5 @@
 import json
+import random
 import re
 from dataclasses import dataclass
 from enum import Enum
@@ -10,6 +11,7 @@ from requests import Response
 from LOGS.Auxiliary import LOGSException, Tools
 from LOGS.Auxiliary.LOGSErrorResponse import LOGSErrorResponse
 from LOGS.Entities.FileEntry import FileEntry
+from LOGS.LOGSOptions import LOGSOptions
 from LOGS.ServerMetaData import ServerMetaData
 
 
@@ -32,7 +34,7 @@ class LOGSConnection:
     """Python class to access the LOGS web API"""
 
     _noErrorStates = set([200, 201, 204])
-    _compatibleAPIVersions = set(["2.0"])
+    _compatibleAPIVersions = set(["3.0"])
     # _compatibleAPIVersions = set(["1.1"])
     __urlRe = re.compile(r"(?:(https*)\:\/\/)*([^\/:]+)(?:\:(\d+))*(?:\/(.*))*")
     __urlApiRe = re.compile(r"api\/(\d+\.\d+)")
@@ -45,7 +47,7 @@ class LOGSConnection:
         url: str,
         apiKey: str,
         use_internal: bool = False,
-        verbose: bool = False,
+        options: Optional[LOGSOptions] = None,
         verify: bool = True,
     ):
         """Checks the connection to the server on creation
@@ -58,13 +60,14 @@ class LOGSConnection:
         :raises Exception: The URL does not define a group.
         :raises Exception: Server cannot be reached.
         """
-
-        self.verbose = verbose
+        self._options = Tools.checkAndConvert(
+            options, LOGSOptions, "options", initOnNone=True
+        )
         self.promptPrefix = "LOGSAPI>"
 
         self.url = url
 
-        if self.verbose:
+        if self._options.showServerInfo:
             self.printServerStatus()
 
         self._apiKey = apiKey
@@ -127,8 +130,10 @@ class LOGSConnection:
         result, error = self.getEndpoint(testEndpoint)
         url = result["url"] if isinstance(result, dict) else self.url
         if error:
-            raise LOGSException("Could not connect to '%s': %s" % (url, error))
-        if self.verbose:
+            raise LOGSException(
+                "Could not connect to '%s': %s" % (url, "\n".join(error.errors))
+            )
+        if self._options.showServerInfo:
             print(
                 self.promptPrefix,
                 "Connection to server '%s://%s%s' successful."
@@ -236,7 +241,7 @@ class LOGSConnection:
 
         :return: The respose of the server and the error code.
         """
-        if self.verbose:
+        if self._options.showRequestUrl:
             paramString = ""
             if parameters:
                 paramString = " ".join(
@@ -282,7 +287,7 @@ class LOGSConnection:
         :return: The respose of the server and the error code.
         """
 
-        if self.verbose:
+        if self._options.showRequestUrl:
             print(self.promptPrefix, "DELETE: %s" % url)
 
         response = requests.delete(
@@ -305,9 +310,12 @@ class LOGSConnection:
         :return: The respose of the server and the error code.
         """
 
-        if self.verbose:
+        if self._options.showRequestUrl:
             print(self.promptPrefix, "PUT: %s" % url)
 
+        if self._options.showRequestBody:
+            print(self.promptPrefix, "BODY: %s" % self.__convertBody(data))
+
         response = requests.put(
             url, headers=self.getHeader(), json=data, verify=self._verify
         )
@@ -336,9 +344,14 @@ class LOGSConnection:
         data: List[MultipartEntry] = [],
         responseType: ResponseTypes = ResponseTypes.JSON,
     ):
-        if self.verbose:
+        if self._options.showRequestUrl:
             print(self.promptPrefix, "POST: %s" % url)
 
+        if self._options.showRequestBody:
+            seperator = "-" * 29 + "".join(
+                [str(random.randint(0, 9)) for _ in range(29)]
+            )
+
         files = []
         for entry in data:
             content: Any = ""
@@ -348,6 +361,22 @@ class LOGSConnection:
                     content = read.read()
             else:
                 content = json.dumps(entry.content)
+
+            if self._options.showRequestBody:
+                print(self.promptPrefix, "BODY: %s" % seperator)
+                print(
+                    self.promptPrefix,
+                    "BODY: %s"
+                    % "Content-Disposition: form-data; name='entry.fileName'",
+                )
+
+                c = (
+                    str(content[:100]) + "..."
+                    if isinstance(content, bytes) and len(content) > 100
+                    else content
+                )
+                print(self.promptPrefix, "BODY: %s" % c)
+
             files.append((entry.name, (entry.fileName, content)))
 
         #### For checking the request
@@ -378,19 +407,7 @@ class LOGSConnection:
 
         :return: The respose of the server and the error code.
         """
-        if self.verbose:
-            paramString = ""
-            if parameters:
-                paramString = " ".join(
-                    ("%s:%s" % (k, v))
-                    for k, v in parameters.items()
-                    if v != None and v != ""
-                )
-            print(
-                self.promptPrefix,
-                "GET: %s %s" % (url, "{" + paramString + "}" if paramString else ""),
-            )
-        if self.verbose:
+        if self._options.showRequestUrl:
             paramString = ""
             if parameters:
                 paramString = " ".join(
@@ -403,6 +420,9 @@ class LOGSConnection:
                 "POST: %s %s" % (url, "{" + paramString + "}" if paramString else ""),
             )
 
+        if self._options.showRequestBody:
+            print(self.promptPrefix, "BODY: %s" % self.__convertBody(data))
+
         response = requests.post(
             url,
             headers=self.getHeader(),
@@ -502,6 +522,14 @@ class LOGSConnection:
     #     # print(">", params)
     #     return {"customFields[%s]" % k: v for k, v in params.items()}
 
+    @classmethod
+    def __convertBody(cls, body) -> str:
+        if body == None:
+            return "None"
+        if isinstance(body, dict) or isinstance(body, list):
+            return json.dumps(body)
+        return body
+
     def __convertResponse(
         self,
         response: Response,

LOGS/LOGSOptions.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class LOGSOptions:
+    showRequestUrl: bool = False
+    showRequestBody: bool = False
+    showServerInfo: bool = False