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

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
 
@@ -947,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)
 
@@ -1049,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)
@@ -1127,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
 
@@ -1143,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

LOGS/Parameters/Color.py

@@ -0,0 +1,92 @@
+from typing import List, Optional
+
+from LOGS.Entity.SerializeableContent import SerializeableContent
+
+
+class SingleColor(SerializeableContent):
+    _color: str
+    _offset: Optional[float]
+    _value: Optional[float]
+
+    @classmethod
+    def bgrIntSigned32bit_to_hexcolor(cls, bgrInt: int):
+        b = bgrInt & 2**8 - 1
+        g = (bgrInt >> 8) & 2**8 - 1
+        r = (bgrInt >> 16) & 2**8 - 1
+        return "#%02x%02x%02x" % (r, g, b)
+
+    @property
+    def color(self) -> str:
+        return self._color
+
+    @color.setter
+    def color(self, value):
+        self._color = value
+
+    @property
+    def offset(self) -> Optional[float]:
+        return self._offset
+
+    @offset.setter
+    def offset(self, value):
+        value = self.checkAndConvert(
+            value, fieldName="offset", fieldType=float, allowNone=True
+        )
+        if value < 0:
+            raise Exception("Color offset value must be >= 0. (Got %f)" % value)
+        if value > 1:
+            raise Exception("Color offset value must be <= 1. (Got %f)" % value)
+        self._offset = value
+
+    @property
+    def value(self) -> Optional[float]:
+        return self._value
+
+    @value.setter
+    def value(self, value):
+        self._value = value
+
+
+class Color(SerializeableContent):
+    _colors: List[SingleColor]
+    _discrete: Optional[bool]
+    _reverse: Optional[bool]
+
+    def __init__(self, ref=None):
+        if ref != None:
+            if isinstance(ref, str):
+                ref = {"colors": [ref]}
+            elif isinstance(ref, list):
+                ref = {"colors": ref}
+
+        super().__init__(ref)
+
+    @classmethod
+    def bgrIntSigned32bit_to_hexcolor(cls, bgrInt: int):
+        return SingleColor.bgrIntSigned32bit_to_hexcolor(bgrInt=bgrInt)
+
+    @property
+    def colors(self) -> List[SingleColor]:
+        return self._colors
+
+    @colors.setter
+    def colors(self, value):
+        self._colors = self.checkListAndConvert(
+            value, fieldType=SingleColor, fieldName="colors"
+        )
+
+    @property
+    def discrete(self) -> Optional[bool]:
+        return self._discrete
+
+    @discrete.setter
+    def discrete(self, value):
+        self._discrete = bool(value)
+
+    @property
+    def reverse(self) -> Optional[bool]:
+        return self._reverse
+
+    @reverse.setter
+    def reverse(self, value):
+        self._reverse = bool(value)

LOGS/Parameters/ParameterBase.py

@@ -0,0 +1,55 @@
+from typing import List, Optional
+
+from LOGS.Entity.SerializeableContent import SerializeableContent
+from LOGS.Parameters.Color import Color
+
+
+class ParameterBase(SerializeableContent):
+    _name: str = ""
+    _tracks: Optional[List[str]] = None
+    _colors: List[Color] = []
+    _active: bool = True
+    _type: str = "None"
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        self._name = self.checkAndConvert(value, fieldType=str, fieldName="name")
+
+    @property
+    def tracks(self) -> Optional[List[str]]:
+        return self._tracks
+
+    @tracks.setter
+    def tracks(self, value):
+        self._tracks = self.checkListAndConvert(
+            value, fieldType=str, fieldName="tracks"
+        )
+
+    @property
+    def active(self) -> bool:
+        return self._active
+
+    @active.setter
+    def active(self, value):
+        self._active = bool(value)
+
+    @property
+    def colors(self) -> Optional[List[Color]]:
+        if len(self._colors) < 1:
+            return None
+
+        return self._colors
+
+    @colors.setter
+    def colors(self, value):
+        self._colors = self.checkListAndConvert(
+            value, fieldType=Color, fieldName="colors"
+        )
+
+    @property
+    def type(self) -> str:
+        return self._type

LOGS/Parameters/ParameterConverter.py

@@ -0,0 +1,24 @@
+from typing import cast
+
+from LOGS.Parameters.ParameterBase import ParameterBase
+from LOGS.Parameters.ParameterElement import ParameterElement
+from LOGS.Parameters.ParameterList import ParameterList
+from LOGS.Parameters.ParameterTable import ParameterTable
+
+
+class ParameterConverter:
+    @classmethod
+    def convert(cls, parameter):
+        if not isinstance(parameter, dict) or "type" not in parameter:
+            return cast(ParameterBase, None)
+
+        if parameter["type"] == "parameter":
+            return ParameterElement(parameter)
+
+        if parameter["type"] == "list":
+            return ParameterList(parameter)
+
+        if parameter["type"] == "table":
+            return ParameterTable(parameter)
+
+        return cast(ParameterBase, None)