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

LOGS/Auxiliary/Constants.py

@@ -2,7 +2,7 @@ import os
 from typing import TYPE_CHECKING, TypeVar, Union
 
 if TYPE_CHECKING:
-    from LOGS.Entities.AutoloadSource import AutoloadSource
+    from LOGS.Entities.Bridge import Bridge
     from LOGS.Entities.Dataset import Dataset
     from LOGS.Entities.Document import Document
     from LOGS.Entities.Equipment import Equipment
@@ -65,7 +65,7 @@ class Constants:
         "Project",
         "Sample",
         "Dataset",
-        "AutoloadSource",
+        "Bridge",
         "Equipment",
         "Experiment",
         "Instrument",

LOGS/Auxiliary/DateTimeConverter.py

@@ -5,7 +5,7 @@ from typing import List, cast
 
 class DateTimeConverter:
     # When adding pattern here put the pattern with most information on top
-    _patterns = ["%Y-%m-%dT%H:%M:%S.%fZ", "%Y-%m-%d"]
+    _patterns = ["%Y-%m-%dT%H:%M:%S.%fZ", "%Y-%m-%dT%H:%M:%SZ", "%Y-%m-%d"]
     utc_offset_re = re.compile(r"([\+-])(\d+)$")
     multiSpace_re = re.compile(r"( {2,})")
 

LOGS/Auxiliary/Exceptions.py

@@ -209,7 +209,7 @@ class EntityDeletingException(LOGSException):
         elif isinstance(entityIds, Entity):
             message = "Could not %s entity %a" % (self._action, entityIds.identifier)
         else:
-            message = "%s entity failed" % (self._action.capitalize() + "ing")
+            message = "%s entity failed" % (self.gerundVerb(self._action.capitalize()))
 
         indent *= 2
         if errors:

LOGS/Auxiliary/MinimalModelGenerator.py

@@ -11,8 +11,8 @@ if TYPE_CHECKING:
 
 def _typeByTypename(fieldType):
     switcher = {
-        "AutoloadSourceMinimal": AutoloadSourceMinimalFromDict,
-        "AutoloadSource": AutoloadSourceMinimalFromDict,
+        "BridgeMinimal": BridgeMinimalFromDict,
+        "Bridge": BridgeMinimalFromDict,
         "DatasetMinimal": DatasetMinimalFromDict,
         "Dataset": DatasetMinimalFromDict,
         "EquipmentMinimal": EquipmentMinimalFromDict,
@@ -87,7 +87,13 @@ def MinimalFromList(
         value = {"id": value}
 
     if isinstance(value, list):
-        value = [({"id": value} if isinstance(value, (int, str)) else v) for v in value]
+        l = []
+        for v in value:
+            if isinstance(v, (int, str)):
+                l.append({"id": v})
+            else:
+                l.append(v)
+        value = l
 
     l = Tools.checkListAndConvert(
         value,
@@ -135,16 +141,16 @@ def _checkAndConvert(
     return result
 
 
-def AutoloadSourceMinimalFromDict(
+def BridgeMinimalFromDict(
     ref: Optional[Union[dict, Constants.ID_TYPE]],
     fieldName: Optional[str] = None,
     connection: Optional["LOGSConnection"] = None,
 ):
-    from LOGS.Entities.AutoloadSourceMinimal import AutoloadSourceMinimal
+    from LOGS.Entities.BridgeMinimal import BridgeMinimal
 
     return _checkAndConvert(
         ref,
-        AutoloadSourceMinimal,
+        BridgeMinimal,
         fieldName=fieldName,
         allowNone=True,
         connection=connection,
@@ -393,3 +399,19 @@ def FormatFormatMinimalFromDict(
         allowNone=True,
         connection=connection,
     )
+
+
+def EntityMinimalWithStrIdFromDict(
+    ref: Optional[Union[dict, Constants.ID_TYPE]],
+    fieldName: Optional[str] = None,
+    connection: Optional["LOGSConnection"] = None,
+):
+    from LOGS.Entity.EntityMinimalWithStrId import EntityMinimalWithStrId
+
+    return _checkAndConvert(
+        ref,
+        EntityMinimalWithStrId,
+        fieldName=fieldName,
+        allowNone=True,
+        connection=connection,
+    )

LOGS/Auxiliary/Tools.py

@@ -214,6 +214,8 @@ class Tools:
             else:
                 raise Exception("Field %a cannot be 'None'." % (fieldName))
 
+        # print("converter", converter)
+        # print(f"{fieldName}({fieldType}) = {value}")
         try:
             value = converter(value)
         except:
@@ -227,6 +229,8 @@ class Tools:
                 )
             )
 
+        # print(f"{fieldName}({fieldType}) => {value}")
+
         if value == None:
             if allowNone:
                 return cast(Any, None)

LOGS/Entities/AutoloadClientInfo.py

@@ -14,7 +14,7 @@ class AutoloadClientInfo(SerializeableContent):
     _operatingSystem: Optional[str] = None
     _firstSeen: Optional[datetime] = None
     _isApproved: Optional[bool] = None
-    _autoloadSourceId: Optional[int] = None
+    _bridgeId: Optional[int] = None
 
     @property
     def id(self) -> Optional[UUID]:
@@ -85,11 +85,9 @@ class AutoloadClientInfo(SerializeableContent):
         self._isApproved = self.checkAndConvertNullable(value, bool, "isApproved")
 
     @property
-    def autoloadSourceId(self) -> Optional[int]:
-        return self._autoloadSourceId
+    def bridgeId(self) -> Optional[int]:
+        return self._bridgeId
 
-    @autoloadSourceId.setter
-    def autoloadSourceId(self, value):
-        self._autoloadSourceId = self.checkAndConvertNullable(
-            value, int, "autoloadSourceId"
-        )
+    @bridgeId.setter
+    def bridgeId(self, value):
+        self._bridgeId = self.checkAndConvertNullable(value, int, "bridgeId")

LOGS/Entities/AutoloadStatus.py

@@ -2,18 +2,18 @@ from datetime import datetime
 from typing import List, Optional
 from uuid import UUID
 
-from LOGS.Entities.AutoloadSourceType import AutoloadSourceType
 from LOGS.Entities.AutoloadStatusError import AutoloadStatusError
+from LOGS.Entities.BridgeType import BridgeType
 from LOGS.Entities.RunState import RunState
 from LOGS.Entity.SerializeableContent import SerializeableClass
 
 
 class AutoloadStatus(SerializeableClass):
-    type: Optional[AutoloadSourceType]
+    type: Optional[BridgeType]
     uuid: Optional[UUID]
     lastUpdated: Optional[datetime]
     counter: Optional[int]
-    autoloadConfigurationId: Optional[int]
+    dataSourceId: Optional[int]
     runState: Optional[RunState]
     startedOn: Optional[datetime]
     duration: Optional[str]

LOGS/Entities/{AutoloadSource.py → Bridge.py}

@@ -4,21 +4,24 @@ from LOGS.Auxiliary.Decorators import Endpoint
 from LOGS.Auxiliary.Exceptions import LOGSMultilineException
 from LOGS.Entities.AutoloadClientInfo import AutoloadClientInfo
 from LOGS.Entities.AutoloadFileInfo import AutoloadFileInfo
-from LOGS.Entities.AutoloadSourceType import AutoloadSourceType
-from LOGS.Entity.EntityWithIntId import EntityWithIntId
+from LOGS.Entities.BridgeRelations import BridgeRelations
+from LOGS.Entities.BridgeType import BridgeType
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
 from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.Interfaces.IRelatedEntity import IRelatedEntity
 from LOGS.LOGSConnection import LOGSConnection
 
 
-@Endpoint("autoload_sources")
-class AutoloadSource(INamedEntity, EntityWithIntId):
-    _type: Optional[AutoloadSourceType]
+@Endpoint("bridges")
+class Bridge(IEntityWithIntId, INamedEntity, IRelatedEntity[BridgeRelations]):
+    _relationType = type(BridgeRelations)
+
+    _type: Optional[BridgeType]
     _hostname: Optional[str]
     _ipAddress: Optional[str]
     _description: Optional[str]
     _username: Optional[str]
     _port: Optional[int]
-    # _autoloadClientInfo: Optional[List[AutoloadClientInfo]]
     _connectedClients: Optional[List[AutoloadClientInfo]]
     _isConnected: Optional[bool]
     _areMultipleClientsConnected: Optional[bool]
@@ -26,8 +29,6 @@ class AutoloadSource(INamedEntity, EntityWithIntId):
     _password: Optional[str]
     _privateKey: Optional[str]
 
-    # _connectedClients: List<AutoloadClientInfo>
-
     def __init__(
         self,
         ref=None,
@@ -71,12 +72,12 @@ class AutoloadSource(INamedEntity, EntityWithIntId):
         )
 
     @property
-    def type(self) -> Optional[AutoloadSourceType]:
+    def type(self) -> Optional[BridgeType]:
         return self._type
 
     @type.setter
     def type(self, value):
-        self._type = self.checkAndConvertNullable(value, AutoloadSourceType, "type")
+        self._type = self.checkAndConvertNullable(value, BridgeType, "type")
 
     @property
     def hostname(self) -> Optional[str]:

LOGS/Entities/BridgeMinimal.py

@@ -0,0 +1,8 @@
+from LOGS.Auxiliary.Decorators import FullModel
+from LOGS.Entities.Bridge import Bridge
+from LOGS.Entity.EntityMinimalWithIntId import EntityMinimalWithIntId
+
+
+@FullModel(Bridge)
+class BridgeMinimal(EntityMinimalWithIntId[Bridge]):
+    pass

LOGS/Entities/BridgeRelations.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 BridgeRelations(EntityRelations):
+    """Relations of a Bridge 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/BridgeRequestParameter.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+from typing import List, Optional
+
+from LOGS.Entities.BridgeType import BridgeType
+from LOGS.Entities.IRelatedEntityRequest import IRelatedEntityRequest
+from LOGS.Entity.EntityRequestParameter import DefaultOrder, EntityRequestParameter
+from LOGS.Interfaces.INamedEntity import INamedEntityRequest
+
+
+@dataclass
+class BridgeRequestParameter(
+    EntityRequestParameter[DefaultOrder], INamedEntityRequest, IRelatedEntityRequest
+):
+    hostnames: Optional[List[str]] = None
+    usernames: Optional[List[str]] = None
+    ipAddresses: Optional[List[str]] = None
+    dataSourceIds: Optional[List[int]] = None
+    types: Optional[List[BridgeType]] = None
+    isConfigured: Optional[bool] = None

LOGS/Entities/{AutoloadSourceType.py → BridgeType.py}

@@ -1,6 +1,6 @@
 from enum import Enum
 
 
-class AutoloadSourceType(Enum):
+class BridgeType(Enum):
     Client = "Client"
     SFTP = "SFTP"

LOGS/Entities/Bridges.py

@@ -0,0 +1,12 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.Bridge import Bridge
+from LOGS.Entities.BridgeRequestParameter import BridgeRequestParameter
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("bridges")
+class Bridges(EntityIterator[Bridge, BridgeRequestParameter]):
+    """LOGS connected class Bridges iterator"""
+
+    _generatorType = Bridge
+    _parameterType = BridgeRequestParameter

LOGS/Entities/{AutoloadConfiguration.py → DataSource.py}

@@ -1,29 +1,53 @@
 from datetime import datetime
+from enum import Enum
 from typing import Dict, List, Optional
 
 from LOGS.Auxiliary.Decorators import Endpoint
 from LOGS.Auxiliary.Exceptions import EntityAPIException
 from LOGS.Auxiliary.MinimalModelGenerator import (
+    BridgeMinimalFromDict,
     InstrumentMinimalFromDict,
     MethodMinimalFromDict,
+    MinimalFromList,
 )
-from LOGS.Entities.AutoloadConfigurationStatus import AutoloadConfigurationStatus
+from LOGS.Entities.BridgeMinimal import BridgeMinimal
+from LOGS.Entities.DataSourceRelations import DataSourceRelations
+from LOGS.Entities.DataSourceStatus import DataSourceStatus
 from LOGS.Entities.Format import Format
+from LOGS.Entities.FormatMinimal import FormatMinimal
 from LOGS.Entities.InstrumentMinimal import InstrumentMinimal
 from LOGS.Entities.MethodMinimal import MethodMinimal
-from LOGS.Entity.EntityWithIntId import EntityWithIntId
+from LOGS.Entity.EntityMinimalWithStrId import EntityMinimalWithStrId
+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.LOGSConnection import LOGSConnection
 
 
-@Endpoint("autoload_configurations")
-class AutoloadConfiguration(
-    INamedEntity, EntityWithIntId, ICreationRecord, IModificationRecord
+class DataSourceType(Enum):
+    Crawling = "Crawling"
+    IconNMR = "IconNMR"
+
+
+@Endpoint("data_sources")
+class DataSource(
+    IEntityWithIntId,
+    INamedEntity,
+    ICreationRecord,
+    IModificationRecord,
+    IRelatedEntity[DataSourceRelations],
 ):
+    _relationType = type(DataSourceRelations)
+
+    _type: Optional[DataSourceType]
+    _bridge: Optional[BridgeMinimal]
+    _formatIds: Optional[List[int]]
+    _customImport: Optional[EntityMinimalWithStrId]
     _enabled: Optional[bool]
-    _autoloadSourceId: Optional[int]
-    _formats: Optional[List[str]]
+    _bridgeId: Optional[int]
+    _formats: Optional[List[FormatMinimal]]
     _directories: Optional[List[str]]
     _intervalInSeconds: Optional[int]
     _method: Optional[MethodMinimal]
@@ -31,7 +55,33 @@ class AutoloadConfiguration(
     _cutoffDate: Optional[datetime]
     _customImportId: Optional[str]
     _parserDefinitions: Optional[Dict[str, Format]]
-    _status: Optional[AutoloadConfigurationStatus]
+    _status: Optional[DataSourceStatus]
+
+    def __init__(
+        self,
+        ref=None,
+        id: Optional[int] = None,
+        connection: Optional[LOGSConnection] = None,
+    ):
+        """Represents a connected LOGS entity type"""
+
+        self._type = None
+        self._bridge = None
+        self._formatIds = None
+        self._customImport = None
+        self._enabled = None
+        self._bridgeId = None
+        self._formats = None
+        self._directories = None
+        self._intervalInSeconds = None
+        self._method = None
+        self._instrument = None
+        self._cutoffDate = None
+        self._customImportId = None
+        self._parserDefinitions = None
+        self._status = None
+
+        super().__init__(ref=ref, id=id, connection=connection)
 
     def triggerAutoload(self):
         connection, endpoint, id = self._getConnectionData()
@@ -49,22 +99,14 @@ class AutoloadConfiguration(
         self._enabled = self.checkAndConvertNullable(value, bool, "enabled")
 
     @property
-    def autoloadSourceId(self) -> Optional[int]:
-        return self._autoloadSourceId
-
-    @autoloadSourceId.setter
-    def autoloadSourceId(self, value):
-        self._autoloadSourceId = self.checkAndConvertNullable(
-            value, int, "autoloadSourceId"
-        )
-
-    @property
-    def formats(self) -> Optional[List[str]]:
+    def formats(self) -> Optional[List[FormatMinimal]]:
         return self._formats
 
     @formats.setter
     def formats(self, value):
-        self._formats = self.checkListAndConvertNullable(value, str, "formats")
+        self._formats = MinimalFromList(
+            value, "FormatMinimal", "formats", connection=self.connection
+        )
 
     @property
     def directories(self) -> Optional[List[str]]:
@@ -121,11 +163,43 @@ class AutoloadConfiguration(
         )
 
     @property
-    def status(self) -> Optional[AutoloadConfigurationStatus]:
+    def status(self) -> Optional[DataSourceStatus]:
         return self._status
 
     @status.setter
     def status(self, value):
-        self._status = self.checkAndConvertNullable(
-            value, AutoloadConfigurationStatus, "status"
+        self._status = self.checkAndConvertNullable(value, DataSourceStatus, "status")
+
+    @property
+    def type(self) -> Optional[DataSourceType]:
+        return self._type
+
+    @type.setter
+    def type(self, value):
+        self._type = self.checkAndConvertNullable(value, DataSourceType, "type")
+
+    @property
+    def bridge(self) -> Optional[BridgeMinimal]:
+        return self._bridge
+
+    @bridge.setter
+    def bridge(self, value):
+        self._bridge = BridgeMinimalFromDict(value, "bridge", self.connection)
+
+    @property
+    def formatIds(self) -> Optional[List[int]]:
+        return self._formatIds
+
+    @formatIds.setter
+    def formatIds(self, value):
+        self._formatIds = self.checkListAndConvertNullable(value, int, "formatIds")
+
+    @property
+    def customImport(self) -> Optional[EntityMinimalWithStrId]:
+        return self._customImport
+
+    @customImport.setter
+    def customImport(self, value):
+        self._customImport = self.checkAndConvertNullable(
+            value, EntityMinimalWithStrId, "customImport"
         )

LOGS/Entities/DataSourceMinimal.py

@@ -0,0 +1,8 @@
+from LOGS.Auxiliary.Decorators import FullModel
+from LOGS.Entities.DataSource import DataSource
+from LOGS.Entity.EntityMinimalWithIntId import EntityMinimalWithIntId
+
+
+@FullModel(DataSource)
+class DataSourceMinimal(EntityMinimalWithIntId[DataSource]):
+    pass

LOGS/Entities/DataSourceRelations.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 DataSourceRelations(EntityRelations):
+    """Relations of a DataSource 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/DataSourceRequestParameter.py

@@ -0,0 +1,44 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import List, Optional
+
+from LOGS.Entities.DataSource import DataSourceType
+from LOGS.Entities.IRelatedEntityRequest import IRelatedEntityRequest
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Interfaces.INamedEntity import INamedEntityRequest
+
+
+class DataSourceOrder(Enum):
+    ID_ASC = "ID_ASC"
+    ID_DESC = "ID_DESC"
+    NAME_ASC = "NAME_ASC"
+    NAME_DESC = "NAME_DESC"
+    TYPE_ASC = "TYPE_ASC"
+    TYPE_DESC = "TYPE_DESC"
+    BRIDGE_ASC = "BRIDGE_ASC"
+    BRIDGE_DESC = "BRIDGE_DESC"
+    INTERVAL_ASC = "INTERVAL_ASC"
+    INTERVAL_DESC = "INTERVAL_DESC"
+    ENABLED_ASC = "ENABLED_ASC"
+    ENABLED_DESC = "ENABLED_DESC"
+    METHOD_ASC = "METHOD_ASC"
+    METHOD_DESC = "METHOD_DESC"
+    INSTRUMENT_ASC = "INSTRUMENT_ASC"
+    INSTRUMENT_DESC = "INSTRUMENT_DESC"
+
+
+@dataclass
+class DataSourceRequestParameter(
+    EntityRequestParameter[DataSourceOrder], INamedEntityRequest, IRelatedEntityRequest
+):
+    enabled: Optional[bool] = None
+    bridgeIds: Optional[List[int]] = None
+    datasetIds: Optional[List[int]] = None
+    formatIds: Optional[List[str]] = None
+    customImportIds: Optional[List[str]] = None
+    directories: Optional[List[str]] = None
+    methodIds: Optional[List[int]] = None
+    instrumentIds: Optional[List[int]] = None
+    sourceHostnames: Optional[List[str]] = None
+    sourceIpAddresses: Optional[List[str]] = None
+    types: Optional[List[DataSourceType]] = None

LOGS/Entities/{AutoloadConfigurationStatus.py → DataSourceStatus.py}

@@ -5,7 +5,7 @@ from LOGS.Entities.AutoloadStatus import AutoloadStatus
 from LOGS.Entity.SerializeableContent import SerializeableClass
 
 
-class AutoloadConfigurationStatus(SerializeableClass):
+class DataSourceStatus(SerializeableClass):
     isConnected: Optional[bool] = None
     nextScheduledDate: Optional[datetime] = None
     lastClientStatus: Optional[AutoloadStatus] = None

LOGS/Entities/DataSources.py

@@ -0,0 +1,12 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.DataSource import DataSource
+from LOGS.Entities.DataSourceRequestParameter import DataSourceRequestParameter
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("autoload_configurations")
+class DataSources(EntityIterator[DataSource, DataSourceRequestParameter]):
+    """LOGS connected class AutouploadSource iterator"""
+
+    _generatorType = DataSource
+    _parameterType = DataSourceRequestParameter