logs-py 4.0.7__py3-none-any.whl

LOGS/Entities/CustomTypeMinimal.py

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

LOGS/Entities/CustomTypeRequestParameter.py

@@ -0,0 +1,60 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Type, cast
+
+from typing_extensions import Self
+
+from LOGS.Entities.CustomFieldModels import CustomTypeEntityType
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Entity.IGenericEntityOrderBy import (
+    IEntryRecordSortingOptions,
+    IGenericEntitySortingOptions,
+    IModificationRecordSortingOptions,
+    INamedEntitySortingOptions,
+)
+from LOGS.Interfaces.IEntryRecord import IEntryRecordRequest
+from LOGS.Interfaces.IModificationRecord import IModificationRecordRequest
+from LOGS.Interfaces.INamedEntity import INamedEntityRequest
+from LOGS.Interfaces.IPaginationRequest import IPaginationRequest
+from LOGS.Interfaces.IPermissionedEntity import IPermissionedEntityRequest
+from LOGS.Interfaces.ISoftDeletable import ISoftDeletableRequest
+
+
+class CustomTypeSortingOptions(
+    IGenericEntitySortingOptions,
+    INamedEntitySortingOptions,
+    IEntryRecordSortingOptions,
+    IModificationRecordSortingOptions,
+):
+    NUMBER_OF_ITEMS: Self = cast(Self, "NUMBER_OF_ITEMS")
+    INVENTORY_NAME: Self = cast(Self, "INVENTORY_NAME")
+    LAYOUT: Self = cast(Self, "LAYOUT")
+
+
+@dataclass
+class CustomTypeRequestParameter(
+    EntityRequestParameter[CustomTypeSortingOptions],
+    IPaginationRequest,
+    IPermissionedEntityRequest,
+    IEntryRecordRequest,
+    IModificationRecordRequest,
+    ISoftDeletableRequest,
+    INamedEntityRequest,
+):
+    _orderByType: Type[CustomTypeSortingOptions] = field(
+        default=CustomTypeSortingOptions, init=False
+    )
+
+    excludeDisabled: Optional[bool] = None
+    isEnabled: Optional[bool] = None
+    customFieldIds: Optional[List[int]] = None
+    entityTypes: Optional[List[CustomTypeEntityType]] = None
+    extendSearchToInventoryItems: Optional[bool] = None
+    parentTypeIds: Optional[List[int]] = None
+    hasRestrictedAddPermission: Optional[bool] = None
+    hasRestrictedEditPermission: Optional[bool] = None
+    hasRestrictedReadPermission: Optional[bool] = None
+    rootHierarchyIds: Optional[List[int]] = None
+    isInventory: Optional[bool] = None
+    isHierarchyRoot: Optional[bool] = None
+    inventoryNames: Optional[List[str]] = None
+    excludeNonInventories: Optional[bool] = None

LOGS/Entities/CustomTypeSection.py

@@ -0,0 +1,63 @@
+from typing import List, Optional
+
+from LOGS.Entities.CustomField import CustomField
+from LOGS.Entities.ILiteraryTypedEntity import ILiteraryTypedEntity
+from LOGS.Entity.ConnectedEntity import ConnectedEntity
+
+
+class CustomTypeSection(ConnectedEntity, ILiteraryTypedEntity):
+    _name: Optional[str] = None
+    _isFolded: Optional[bool] = None
+    _isHeadless: Optional[bool] = None
+    _customFields: Optional[List[CustomField]] = None
+
+    _type = "CustomTypeSection"
+
+    def contentToString(self, indentation: int = 1, hideNone: bool = False) -> str:
+        bak = self._noSerialize
+        self._noSerialize = [*bak, "customFields"]
+        tab = self._indentationString * indentation
+        tabContent = self._indentationString * (indentation + 1)
+        s = super().contentToString(indentation, hideNone)
+        s += f"{tab}customFields=\n"
+        self._noSerialize = bak
+        for field in self.customFields or []:
+            if not field and hideNone:
+                continue
+            s += f"{tabContent}{str(field)}\n"
+
+        return s
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        self._name = self.checkAndConvertNullable(value, str, "name")
+
+    @property
+    def isFolded(self) -> Optional[bool]:
+        return self._isFolded
+
+    @isFolded.setter
+    def isFolded(self, value):
+        self._isFolded = self.checkAndConvertNullable(value, bool, "isFolded")
+
+    @property
+    def isHeadless(self) -> Optional[bool]:
+        return self._isHeadless
+
+    @isHeadless.setter
+    def isHeadless(self, value):
+        self._isHeadless = self.checkAndConvertNullable(value, bool, "isHeadless")
+
+    @property
+    def customFields(self) -> Optional[List[CustomField]]:
+        return self._customFields
+
+    @customFields.setter
+    def customFields(self, value):
+        self._customFields = self.checkListAndConvertNullable(
+            value, CustomField, "customFields"
+        )

LOGS/Entities/CustomTypes.py

@@ -0,0 +1,12 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.CustomType import CustomType
+from LOGS.Entities.CustomTypeRequestParameter import CustomTypeRequestParameter
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("types")
+class CustomTypes(EntityIterator[CustomType, CustomTypeRequestParameter]):
+    """LOGS connected CustomTypes iterator"""
+
+    _generatorType = CustomType
+    _parameterType = CustomTypeRequestParameter

LOGS/Entities/DataFormat.py

@@ -0,0 +1,97 @@
+from typing import List, Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entity.EntityWithStrId import EntityWithStrId
+from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.Interfaces.IPermissionedEntity import IGenericPermissionEntity
+
+
+@Endpoint("data_formats")
+class DataFormat(EntityWithStrId, INamedEntity, IGenericPermissionEntity):
+
+    _description: Optional[str] = None
+    _formatVersion: Optional[List[str]] = []
+    _isCustom: Optional[bool] = None
+    _version: Optional[str] = None
+    _hasVisualization: Optional[bool] = None
+
+    _vendors: List[str] = []
+    _methods: List[str] = []
+    _formats: List[str] = []
+    _instruments: List[str] = []
+
+    @property
+    def formatVersion(self) -> Optional[List[str]]:
+        return self._formatVersion
+
+    @formatVersion.setter
+    def formatVersion(self, value):
+        self._formatVersion = self.checkListAndConvertNullable(
+            value, str, "formatVersion"
+        )
+
+    @property
+    def vendors(self) -> List[str]:
+        return self._vendors
+
+    @vendors.setter
+    def vendors(self, value):
+        self._vendors = self.checkListAndConvert(value, str, "vendors")
+
+    @property
+    def methods(self) -> List[str]:
+        return self._methods
+
+    @methods.setter
+    def methods(self, value):
+        self._methods = self.checkListAndConvert(value, str, "methods")
+
+    @property
+    def formats(self) -> List[str]:
+        return self._formats
+
+    @formats.setter
+    def formats(self, value):
+        self._formats = self.checkListAndConvert(value, str, "formats")
+
+    @property
+    def instruments(self) -> List[str]:
+        return self._instruments
+
+    @instruments.setter
+    def instruments(self, value):
+        self._instruments = self.checkListAndConvert(value, str, "instruments")
+
+    @property
+    def hasVisualization(self) -> Optional[bool]:
+        return self._hasVisualization
+
+    @hasVisualization.setter
+    def hasVisualization(self, value: Optional[bool]):
+        self._hasVisualization = self.checkAndConvertNullable(
+            value, bool, "hasVisualization"
+        )
+
+    @property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @description.setter
+    def description(self, value: Optional[str]):
+        self._description = self.checkAndConvertNullable(value, str, "description")
+
+    @property
+    def isCustom(self) -> Optional[bool]:
+        return self._isCustom
+
+    @isCustom.setter
+    def isCustom(self, value: Optional[bool]):
+        self._isCustom = self.checkAndConvertNullable(value, bool, "isCustom")
+
+    @property
+    def version(self) -> Optional[str]:
+        return self._version
+
+    @version.setter
+    def version(self, value: Optional[str]):
+        self._version = self.checkAndConvertNullable(value, str, "version")

LOGS/Entities/DataFormatInstrument.py

@@ -0,0 +1,18 @@
+from typing import Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entity.EntityWithStrId import EntityWithStrId
+from LOGS.Interfaces.INamedEntity import INamedEntity
+
+
+@Endpoint("data_format_instruments")
+class DataFormatInstrument(EntityWithStrId, INamedEntity):
+    _description: Optional[str] = None
+
+    @property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @description.setter
+    def description(self, value):
+        self._description = self.checkAndConvertNullable(value, str, "description")

LOGS/Entities/DataFormatInstrumentMinimal.py

@@ -0,0 +1,8 @@
+from LOGS.Auxiliary.Decorators import FullModel
+from LOGS.Entities.DataFormatInstrument import DataFormatInstrument
+from LOGS.Entity.EntityMinimalWithStrId import EntityMinimalWithStrId
+
+
+@FullModel(DataFormatInstrument)
+class DataFormatInstrumentMinimal(EntityMinimalWithStrId[DataFormatInstrument]):
+    pass

LOGS/Entities/DataFormatInstrumentRequestParameter.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass, field
+from typing import Type
+
+from LOGS.Entity.EntityRequestParameter import (
+    DefaultSortingOptions,
+    EntityRequestParameter,
+)
+from LOGS.Interfaces.INamedEntity import INamedEntityRequest
+
+
+@dataclass
+class DataFormatInstrumentRequestParameter(
+    EntityRequestParameter[DefaultSortingOptions], INamedEntityRequest
+):
+    _orderByType: Type[DefaultSortingOptions] = field(
+        default=DefaultSortingOptions, init=False
+    )

LOGS/Entities/DataFormatInstruments.py

@@ -0,0 +1,16 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.DataFormatInstrument import DataFormatInstrument
+from LOGS.Entities.DataFormatInstrumentRequestParameter import (
+    DataFormatInstrumentRequestParameter,
+)
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("data_format_instruments")
+class DataFormatInstruments(
+    EntityIterator[DataFormatInstrument, DataFormatInstrumentRequestParameter]
+):
+    """LOGS connected class DataFormatInstrument iterator"""
+
+    _generatorType = DataFormatInstrument
+    _parameterType = DataFormatInstrumentRequestParameter

LOGS/Entities/DataFormatMinimal.py

@@ -0,0 +1,18 @@
+from typing import List, Optional
+
+from LOGS.Auxiliary.Decorators import FullModel
+from LOGS.Entities.DataFormat import DataFormat
+from LOGS.Entity.EntityMinimalWithStrId import EntityMinimalWithStrId
+
+
+@FullModel(DataFormat)
+class DataFormatMinimal(EntityMinimalWithStrId[DataFormat]):
+    _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/DataFormatRequestParameter.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Type
+
+from LOGS.Entity.EntityRequestParameter import (
+    DefaultSortingOptions,
+    EntityRequestParameter,
+)
+
+
+@dataclass
+class DataFormatRequestParameter(EntityRequestParameter[DefaultSortingOptions]):
+    _orderByType: Type[DefaultSortingOptions] = field(
+        default=DefaultSortingOptions, init=False
+    )
+
+    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/DataFormats.py

@@ -0,0 +1,12 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities import DataFormat
+from LOGS.Entities.DataFormatRequestParameter import DataFormatRequestParameter
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("data_formats")
+class DataFormats(EntityIterator[DataFormat, DataFormatRequestParameter]):
+    """LOGS connected Formats iterator"""
+
+    _generatorType = DataFormat
+    _parameterType = DataFormatRequestParameter

LOGS/Entities/DataSource.py

@@ -0,0 +1,218 @@
+from datetime import datetime
+from enum import Enum
+from typing import TYPE_CHECKING, List, Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Auxiliary.Exceptions import EntityAPIException
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Entities.Bridge import Bridge
+from LOGS.Entities.DataFormat import DataFormat
+from LOGS.Entities.DatasetTemplate import DatasetTemplate
+from LOGS.Entities.DataSourceConnectionStatus import DataSourceConnectionStatus
+from LOGS.Entities.DataSourceStatusIterator import DataSourceStatusIterator
+from LOGS.Entities.DataSourceStatusRequestParameter import (
+    DataSourceStatusRequestParameter,
+    DataSourceStatusSortingOptions,
+)
+from LOGS.Entities.FileExcludePattern import FileExcludePattern
+from LOGS.Entity.EntityMinimalWithStrId import EntityMinimalWithStrId
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
+from LOGS.Interfaces.IEntryRecord import IEntryRecord
+from LOGS.Interfaces.IModificationRecord import IModificationRecord
+from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.Interfaces.IPermissionedEntity import IGenericPermissionEntity
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
+
+if TYPE_CHECKING:
+    from LOGS.Entities.DataFormatMinimal import DataFormatMinimal
+
+
+class DataSourceType(Enum):
+    Crawler = "Crawler"
+    IconNMR = "IconNMR"
+
+
+class DataSourceUpdateMode(Enum):
+    Deactivated = "Deactivated"
+    UseHash = "UseHash"
+    UsePath = "UsePath"
+
+
+@Endpoint("data_sources")
+class DataSource(
+    IEntityWithIntId,
+    INamedEntity,
+    IUniqueEntity,
+    IEntryRecord,
+    IModificationRecord,
+    IGenericPermissionEntity,
+):
+    _type: Optional[DataSourceType] = None
+    _enabled: Optional[bool] = None
+    _bridge: Optional["Bridge"] = None
+    _format: Optional["DataFormatMinimal"] = None
+    _customImport: Optional[EntityMinimalWithStrId] = None
+    _datasetUpdateMode: Optional[DataSourceUpdateMode] = None
+    _parser: Optional[DataFormat] = None
+    _directories: Optional[List[str]] = None
+    _intervalInSeconds: Optional[int] = None
+    _cutoffDate: Optional[datetime] = None
+    _fileExcludePatterns: Optional[List[FileExcludePattern]] = None
+    _status: Optional[DataSourceConnectionStatus] = None
+    _datasetTemplate: Optional[DatasetTemplate] = None
+
+    def triggerAutoload(self):
+        connection, endpoint, id = self._getConnectionData()
+
+        _, responseError = connection.getEndpoint(endpoint + [id, "trigger_autoload"])
+        if responseError:
+            raise EntityAPIException(entity=self, responseError=responseError)
+
+    @property
+    def history(self) -> Optional[DataSourceStatusIterator]:
+        return DataSourceStatusIterator(
+            self._getConnection(),
+            DataSourceStatusRequestParameter(
+                dataSourceIds=[self.id],
+                sortBy=DataSourceStatusSortingOptions.STARTED_ON,
+            ),
+        )
+
+    @property
+    def enabled(self) -> Optional[bool]:
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, value):
+        self._enabled = self.checkAndConvertNullable(value, bool, "enabled")
+
+    @property
+    def formats(self) -> Optional[List["DataFormatMinimal"]]:
+        return self._formats
+
+    @formats.setter
+    def formats(self, value):
+        self._formats = MinimalModelGenerator.MinimalFromList(
+            value, "DataFormatMinimal", "formats", connection=self._getConnection()
+        )
+
+    @property
+    def directories(self) -> Optional[List[str]]:
+        return self._directories
+
+    @directories.setter
+    def directories(self, value):
+        self._directories = self.checkListAndConvertNullable(value, str, "directories")
+
+    @property
+    def intervalInSeconds(self) -> Optional[int]:
+        return self._intervalInSeconds
+
+    @intervalInSeconds.setter
+    def intervalInSeconds(self, value):
+        self._intervalInSeconds = self.checkAndConvertNullable(
+            value, int, "intervalInSeconds"
+        )
+
+    @property
+    def cutoffDate(self) -> Optional[datetime]:
+        return self._cutoffDate
+
+    @cutoffDate.setter
+    def cutoffDate(self, value):
+        self._cutoffDate = self.checkAndConvertNullable(value, datetime, "cutoffDate")
+
+    @property
+    def fileExcludePatterns(self) -> Optional[List[FileExcludePattern]]:
+        return self._fileExcludePatterns
+
+    @fileExcludePatterns.setter
+    def fileExcludePatterns(self, value):
+        self._fileExcludePatterns = self.checkListAndConvertNullable(
+            value, FileExcludePattern, "fileExcludePatterns"
+        )
+
+    @property
+    def customImportId(self) -> Optional[str]:
+        return self._customImportId
+
+    @customImportId.setter
+    def customImportId(self, value):
+        print("customImportId", value)
+        self._customImportId = self.checkAndConvertNullable(
+            value, str, "customImportId"
+        )
+
+    @property
+    def status(self) -> Optional[DataSourceConnectionStatus]:
+        return self._status
+
+    @status.setter
+    def status(self, value):
+        self._status = self.checkAndConvertNullable(
+            value, DataSourceConnectionStatus, "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["Bridge"]:
+        return self._bridge
+
+    @bridge.setter
+    def bridge(self, value):
+        self._bridge = self.checkAndConvertNullable(value, Bridge, "bridge")
+
+    @property
+    def format(self) -> Optional["DataFormatMinimal"]:
+        return self._format
+
+    @format.setter
+    def format(self, value):
+        self._format = MinimalModelGenerator.MinimalFromSingle(
+            value, "DataFormatMinimal", "format", connection=self._getConnection()
+        )
+
+    @property
+    def customImport(self) -> Optional[EntityMinimalWithStrId]:
+        return self._customImport
+
+    @customImport.setter
+    def customImport(self, value):
+        self._customImport = self.checkAndConvertNullable(
+            value, EntityMinimalWithStrId, "customImport"
+        )
+
+    @property
+    def datasetUpdateMode(self) -> Optional[DataSourceUpdateMode]:
+        return self._datasetUpdateMode
+
+    @datasetUpdateMode.setter
+    def datasetUpdateMode(self, value):
+        self._datasetUpdateMode = self.checkAndConvertNullable(
+            value, DataSourceUpdateMode, "datasetUpdateMode"
+        )
+
+    @property
+    def parser(self) -> Optional[DataFormat]:
+        return self._parser
+
+    @parser.setter
+    def parser(self, value):
+        self._parser = self.checkAndConvertNullable(value, DataFormat, "parser")
+
+    @property
+    def datasetTemplate(self) -> Optional[DatasetTemplate]:
+        return self._datasetTemplate
+
+    @datasetTemplate.setter
+    def datasetTemplate(self, value):
+        self._datasetTemplate = self.checkAndConvertNullable(
+            value, DatasetTemplate, "datasetTemplate"
+        )

LOGS/Entities/DataSourceConnectionStatus.py

@@ -0,0 +1,12 @@
+from datetime import datetime
+from typing import List, Optional
+
+from LOGS.Entities.DataSourceStatus import DataSourceStatus
+from LOGS.Entity.SerializableContent import SerializableClass
+
+
+class DataSourceConnectionStatus(SerializableClass):
+    isConnected: Optional[bool] = None
+    nextScheduledDate: Optional[datetime] = None
+    lastClientStatus: Optional[DataSourceStatus] = None
+    statusHistory: Optional[List[DataSourceStatus]] = None

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/DataSourceRequestParameter.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Type, cast
+
+from typing_extensions import Self
+
+from LOGS.Entities.BridgeType import BridgeType
+from LOGS.Entities.DataSource import DataSourceType
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Entity.IGenericEntityOrderBy import (
+    IEntryRecordSortingOptions,
+    IGenericEntitySortingOptions,
+    IModificationRecordSortingOptions,
+    INamedEntitySortingOptions,
+)
+from LOGS.Interfaces.IEntryRecord import IEntryRecordRequest
+from LOGS.Interfaces.IModificationRecord import IModificationRecordRequest
+from LOGS.Interfaces.INamedEntity import INamedEntityRequest
+from LOGS.Interfaces.IPermissionedEntity import IPermissionedEntityRequest
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntityRequest
+
+
+class DataSourceSortingOptions(
+    IGenericEntitySortingOptions,
+    INamedEntitySortingOptions,
+    IEntryRecordSortingOptions,
+    IModificationRecordSortingOptions,
+):
+    TYPE: Self = cast(Self, "TYPE")
+    BRIDGE: Self = cast(Self, "BRIDGE")
+    BRIDGE_TYPE: Self = cast(Self, "BRIDGE_TYPE")
+    INTERVAL: Self = cast(Self, "INTERVAL")
+    ENABLED: Self = cast(Self, "ENABLED")
+
+
+@dataclass
+class DataSourceRequestParameter(
+    EntityRequestParameter[DataSourceSortingOptions],
+    INamedEntityRequest,
+    IUniqueEntityRequest,
+    IEntryRecordRequest,
+    IModificationRecordRequest,
+    IPermissionedEntityRequest,
+):
+    _orderByType: Type[DataSourceSortingOptions] = field(
+        default=DataSourceSortingOptions, init=False
+    )
+
+    enabled: Optional[bool] = None
+    bridgeIds: Optional[List[int]] = None
+    bridgeTypes: Optional[List[BridgeType]] = None
+    datasetIds: Optional[List[int]] = None
+    formatIds: Optional[List[str]] = None
+    customImportIds: Optional[List[str]] = None
+    directories: Optional[List[str]] = None
+    sourceHostnames: Optional[List[str]] = None
+    sourceIpAddresses: Optional[List[str]] = None
+    types: Optional[List[DataSourceType]] = None