logs-py 4.0.7__py3-none-any.whl

LOGS/Entities/FormattedTable/DatatypeFormattedTableCell.py

@@ -0,0 +1,108 @@
+from typing import Literal, Optional, Union
+
+from LOGS.Entities.FormattedTable.DatatypeFormattedTableSettings import (
+    DatatypeFormattedTableSettings,
+)
+from LOGS.Entity.SerializableContent import SerializableContent
+
+_VTypeType = Literal["int", "float", "str", "bool"]
+_ValueType = Union[str, int, float, bool, None]
+
+
+class DatatypeFormattedTableCell(SerializableContent):
+    __vtype = {"int": int, "float": float, "str": str, "bool": bool}
+
+    _id: str = ""
+    _type: str = "formatted_table_cell"
+    _value: Optional[_ValueType] = None
+    _vtype: _VTypeType = "str"
+    _row: int = 0
+    _column: int = 0
+    _settings: Optional[DatatypeFormattedTableSettings] = None
+
+    @property
+    def type(self) -> str:
+        return self._type
+
+    @type.setter
+    def type(self, value):
+        self._type = value
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        self._name = value
+
+    @property
+    def value(self) -> _ValueType:
+        return self._value
+
+    @value.setter
+    def value(self, value):
+        vtype = self.vtype if self.vtype else type(value).__name__
+
+        converter = self.__vtype.get(vtype, None)
+        if converter:
+            try:
+                self._value = converter(value)
+                self._vtype = vtype
+            except:
+                raise Exception(
+                    "ERROR: could not convert "
+                    + "' value '"
+                    + value
+                    + "' to type '"
+                    + value
+                    + "'"
+                )
+        else:
+            raise Exception(
+                "Unknown vtype %a. (Expected one of '%s')"
+                % (vtype, ", ".join(self.__vtype.keys()))
+            )
+
+    @property
+    def vtype(self) -> _VTypeType:
+        return self._vtype
+
+    @vtype.setter
+    def vtype(self, value):
+        if value not in self.__vtype:
+            raise Exception(
+                "Unknown vtype %a. (Expected one of '%s')"
+                % (value, ", ".join(self.__vtype.keys()))
+            )
+        self._vtype = value
+
+    @property
+    def row(self) -> int:
+        return self._row
+
+    @row.setter
+    def row(self, value):
+        self._row = value
+
+    @property
+    def column(self) -> int:
+        return self._column
+
+    @column.setter
+    def column(self, value):
+        self._column = value
+
+    @property
+    def id(self) -> str:
+        return f"{self.row}x{self.column}"
+
+    @property
+    def settings(self) -> Optional[DatatypeFormattedTableSettings]:
+        return self._settings
+
+    @settings.setter
+    def settings(self, value):
+        self._settings = self.checkAndConvert(
+            value, fieldName="settings", fieldType=DatatypeFormattedTableSettings
+        )

LOGS/Entities/FormattedTable/DatatypeFormattedTableSettings.py

@@ -0,0 +1,11 @@
+from typing import Dict, List, Optional
+
+from LOGS.Entity.SerializableContent import SerializableClass
+
+
+class DatatypeFormattedTableSettings(SerializableClass):
+    _type: str = "formatted_table"
+    _name: Optional[str] = None
+    _id: str = ""
+    _cells: List[str] = []
+    _cellIds: Dict[str, str] = {}

LOGS/Entities/FormattedTable/__init__.py

@@ -0,0 +1,9 @@
+"""
+This package is written for the LOGS Repository.
+
+It's objects can be used to write your own dataset parser.
+
+License:
+Permission to use this libraray and all of its contents is
+strictly permitted to the Signals Company.
+"""

LOGS/Entities/HierarchyLeaf.py

@@ -0,0 +1,15 @@
+from typing import Optional
+
+from LOGS.Entity.SerializableContent import SerializableContent
+
+
+class HierarchyLeaf(SerializableContent):
+    _track: Optional[str] = None
+
+    @property
+    def track(self) -> Optional[str]:
+        return self._track
+
+    @track.setter
+    def track(self, value):
+        self._track = self.checkAndConvertNullable(value, str, "track")

LOGS/Entities/HierarchyNode.py

@@ -0,0 +1,40 @@
+from typing import Optional, Sequence, Union
+
+from LOGS.Entities.HierarchyLeaf import HierarchyLeaf
+from LOGS.Entity.SerializableContent import SerializableContent
+
+
+class HierarchyNode(SerializableContent):
+    _name: Optional[str] = None
+    _content: Optional[Sequence[Union["HierarchyNode", HierarchyLeaf]]] = None
+
+    def _converter(self, value):
+        if isinstance(value, dict) and "type" in value:
+            type = value["type"]
+            if type == "node":
+                return self.checkAndConvert(value, HierarchyNode, "node.content")
+            elif type == "leaf":
+                return self.checkAndConvert(value, HierarchyLeaf, "leaf")
+        return None
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        self._name = self.checkAndConvertNullable(value, str, "name")
+
+    @property
+    def content(self) -> Optional[Sequence[Union["HierarchyNode", HierarchyLeaf]]]:
+        return self._content
+
+    @content.setter
+    def content(self, value):
+        l = self.checkListAndConvertNullable(
+            value,
+            fieldType=HierarchyNode,
+            converter=self._converter,
+            fieldName="content",
+        )
+        self._content = [c for c in l if c]

LOGS/Entities/ILiteraryTypedEntity.py

@@ -0,0 +1,19 @@
+from typing import Any, Optional, cast
+
+from LOGS.Auxiliary.Exceptions import IllegalFieldValueException
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+
+class ILiteraryTypedEntity(IEntityInterface):
+    _type: str = cast(Any, None)
+
+    @property
+    def type(self) -> Optional[str]:
+        return self._type
+
+    @type.setter
+    def type(self, value):
+        if value != self._type:
+            raise IllegalFieldValueException(
+                self, "type", value, f"Only value '{self._type}' allowed."
+            )

LOGS/Entities/InventoryItem.py

@@ -0,0 +1,102 @@
+from typing import TYPE_CHECKING, Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
+from LOGS.Interfaces.IEntryRecord import IEntryRecord
+from LOGS.Interfaces.IHierarchicalEntity import IHierarchicalEntity
+from LOGS.Interfaces.ILockableEntity import ILockableEntity
+from LOGS.Interfaces.IModificationRecord import IModificationRecord
+from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.Interfaces.IPermissionedEntity import IGenericPermissionEntity
+from LOGS.Interfaces.IProjectBased import IProjectBased
+from LOGS.Interfaces.ISignableEntity import ISignableEntity
+from LOGS.Interfaces.ISoftDeletable import ISoftDeletable
+from LOGS.Interfaces.ITypedEntity import ITypedEntity
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
+
+if TYPE_CHECKING:
+    from LOGS.Entities.InventoryItemMinimal import InventoryItemMinimal
+
+
+@Endpoint("inventory_items")
+class InventoryItem(
+    IEntityWithIntId,
+    IUniqueEntity,
+    INamedEntity,
+    IEntryRecord,
+    IModificationRecord,
+    ISoftDeletable,
+    ILockableEntity,
+    IGenericPermissionEntity,
+    ITypedEntity,
+    IProjectBased,
+    IHierarchicalEntity,
+    ISignableEntity,
+):
+
+    _rootCustomType: Optional["InventoryItemMinimal"] = None
+    _isRootItem: Optional[bool] = None
+    _isHierarchyItem: Optional[bool] = None
+
+    _isDeletedViaHierarchy: Optional[bool] = None
+    _isLockedViaHierarchy: Optional[bool] = None
+    _isSignedViaHierarchy: Optional[bool] = None
+
+    @property
+    def rootCustomType(self) -> Optional["InventoryItemMinimal"]:
+        return self._rootCustomType
+
+    @rootCustomType.setter
+    def rootCustomType(self, value):
+        self._rootCustomType = MinimalModelGenerator.MinimalFromSingle(
+            value, "InventoryItemMinimal", "rootCustomType", self._getConnection()
+        )
+
+    @property
+    def isRootItem(self) -> Optional[bool]:
+        return self._isRootItem
+
+    @isRootItem.setter
+    def isRootItem(self, value):
+        self._isRootItem = self.checkAndConvertNullable(value, bool, "isRootItem")
+
+    @property
+    def isHierarchyItem(self) -> Optional[bool]:
+        return self._isHierarchyItem
+
+    @isHierarchyItem.setter
+    def isHierarchyItem(self, value):
+        self._isHierarchyItem = self.checkAndConvertNullable(
+            value, bool, "isHierarchyItem"
+        )
+
+    @property
+    def isDeletedViaHierarchy(self) -> Optional[bool]:
+        return self._isDeletedViaHierarchy
+
+    @isDeletedViaHierarchy.setter
+    def isDeletedViaHierarchy(self, value):
+        self._isDeletedViaHierarchy = self.checkAndConvertNullable(
+            value, bool, "isDeletedViaHierarchy"
+        )
+
+    @property
+    def isLockedViaHierarchy(self) -> Optional[bool]:
+        return self._isLockedViaHierarchy
+
+    @isLockedViaHierarchy.setter
+    def isLockedViaHierarchy(self, value):
+        self._isLockedViaHierarchy = self.checkAndConvertNullable(
+            value, bool, "isLockedViaHierarchy"
+        )
+
+    @property
+    def isSignedViaHierarchy(self) -> Optional[bool]:
+        return self._isSignedViaHierarchy
+
+    @isSignedViaHierarchy.setter
+    def isSignedViaHierarchy(self, value):
+        self._isSignedViaHierarchy = self.checkAndConvertNullable(
+            value, bool, "isSignedViaHierarchy"
+        )

LOGS/Entities/InventoryItemMinimal.py

@@ -0,0 +1,25 @@
+from typing import Optional
+
+from LOGS.Auxiliary.Decorators import FullModel
+from LOGS.Entities.InventoryItem import InventoryItem
+from LOGS.Entity.EntityMinimalWithIntId import EntityMinimalWithIntId
+
+
+@FullModel(InventoryItem)
+class InventoryItemMinimal(EntityMinimalWithIntId[InventoryItem]):
+    _inventoryName: Optional[str] = None
+
+    @property
+    def inventoryName(self) -> Optional[str]:
+        return self._inventoryName
+
+    @inventoryName.setter
+    def inventoryName(self, value):
+        self._inventoryName = self.checkAndConvert(
+            value, str, "inventoryName", allowNone=True
+        )
+
+    def __str__(self):
+        s = f" class:'{self.inventoryName}'" if self.inventoryName else ""
+        s += " name:'%s'" % (self.name if self.name else "")
+        return "<%s id:%s%s>" % (type(self).__name__, str(self.id), s)

LOGS/Entities/InventoryItemRequestParameter.py

@@ -0,0 +1,58 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Type, cast
+
+from typing_extensions import Self
+
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Entity.IGenericEntityOrderBy import (
+    IEntryRecordSortingOptions,
+    IGenericEntitySortingOptions,
+    IModificationRecordSortingOptions,
+    INamedEntitySortingOptions,
+    ITypedEntitySortingOptions,
+)
+from LOGS.Interfaces.IEntryRecord import IEntryRecordRequest
+from LOGS.Interfaces.IHierarchicalEntity import IHierarchicalEntityRequest
+from LOGS.Interfaces.ILockableEntity import ILockableEntityRequest
+from LOGS.Interfaces.IModificationRecord import IModificationRecordRequest
+from LOGS.Interfaces.IPaginationRequest import IPaginationRequest
+from LOGS.Interfaces.IProjectBased import IProjectBasedRequest
+from LOGS.Interfaces.ISignableEntity import ISignableEntityRequest
+from LOGS.Interfaces.ISoftDeletable import ISoftDeletableRequest
+from LOGS.Interfaces.ITypedEntity import ITypedEntityRequest
+
+
+class InventoryItemsSortingOptions(
+    IGenericEntitySortingOptions,
+    INamedEntitySortingOptions,
+    IEntryRecordSortingOptions,
+    IModificationRecordSortingOptions,
+    ITypedEntitySortingOptions,
+):
+    INVENTORY_NAME: Self = cast(Self, "INVENTORY_NAME")
+    NUMBER_OF_ITEMS: Self = cast(Self, "NUMBER_OF_ITEMS")
+    LAYOUT: Self = cast(Self, "LAYOUT")
+
+
+@dataclass
+class InventoryItemRequestParameter(
+    EntityRequestParameter[InventoryItemsSortingOptions],
+    IPaginationRequest,
+    IEntryRecordRequest,
+    IModificationRecordRequest,
+    ISoftDeletableRequest,
+    IHierarchicalEntityRequest,
+    IProjectBasedRequest,
+    ITypedEntityRequest,
+    ILockableEntityRequest,
+    ISignableEntityRequest,
+):
+    _orderByType: Type[InventoryItemsSortingOptions] = field(
+        default=InventoryItemsSortingOptions, init=False
+    )
+
+    childrenOfParentIds: Optional[List[int]] = None
+    descendantsOfIds: Optional[List[int]] = None
+    excludeHierarchyChildren: Optional[bool] = None
+    isHierarchyRoot: Optional[bool] = None
+    inventoryItemIds: Optional[List[int]] = None

LOGS/Entities/InventoryItems.py

@@ -0,0 +1,12 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.InventoryItem import InventoryItem
+from LOGS.Entities.InventoryItemRequestParameter import InventoryItemRequestParameter
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("inventory_items")
+class InventoryItems(EntityIterator[InventoryItem, InventoryItemRequestParameter]):
+    """LOGS connected InventoryItems iterator"""
+
+    _generatorType = InventoryItem
+    _parameterType = InventoryItemRequestParameter

LOGS/Entities/LabNotebook.py

@@ -0,0 +1,33 @@
+from typing import Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
+from LOGS.Interfaces.ILockableEntity import ILockableEntity
+from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.Interfaces.IPermissionedEntity import IGenericPermissionEntity
+from LOGS.Interfaces.IProjectBased import IProjectBased
+from LOGS.Interfaces.ISignableEntity import ISignableEntity
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
+from LOGS.Interfaces.IVersionedEntity import IVersionedEntity
+
+
+@Endpoint("lab_notebooks")
+class LabNotebook(
+    IEntityWithIntId,
+    IUniqueEntity,
+    INamedEntity,
+    IVersionedEntity,
+    IProjectBased,
+    IGenericPermissionEntity,
+    ILockableEntity,
+    ISignableEntity,
+):
+    _description: Optional[str] = None
+
+    @property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @description.setter
+    def description(self, value: str):
+        self._description = self.checkAndConvertNullable(value, str, "description")

LOGS/Entities/LabNotebookEntries.py

@@ -0,0 +1,16 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.LabNotebookEntry import LabNotebookEntry
+from LOGS.Entities.LabNotebookEntryRequestParameter import (
+    LabNotebookEntryRequestParameter,
+)
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("lab_notebook_entries")
+class LabNotebookEntries(
+    EntityIterator[LabNotebookEntry, LabNotebookEntryRequestParameter]
+):
+    """LOGS connected LabNotebookEntry iterator"""
+
+    _generatorType = LabNotebookEntry
+    _parameterType = LabNotebookEntryRequestParameter

LOGS/Entities/LabNotebookEntry.py

@@ -0,0 +1,106 @@
+from datetime import datetime
+from typing import Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Auxiliary.Exceptions import EntityFetchingException, EntityIncompleteException
+from LOGS.Entities.LabNotebookEntryContent.EntryContentConverter import (
+    EntryContentConverter,
+)
+from LOGS.Entities.LabNotebookEntryContent.EntryContentDocument import (
+    EntryContentDocument,
+)
+from LOGS.Entity.EntityMinimalWithIntId import EntityMinimalWithIntId
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
+from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.Interfaces.IPermissionedEntity import IGenericPermissionEntity
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
+from LOGS.Interfaces.IVersionedEntity import IVersionedEntity
+
+
+@Endpoint("lab_notebook_entries")
+class LabNotebookEntry(
+    IEntityWithIntId,
+    IUniqueEntity,
+    INamedEntity,
+    IVersionedEntity,
+    IGenericPermissionEntity,
+):
+    _noContent: bool = True
+
+    _alias: Optional[str] = None
+    _labNotebook: Optional[EntityMinimalWithIntId] = None
+    _labNotebookExperiment: Optional[EntityMinimalWithIntId] = None
+    _entryDate: Optional[datetime] = None
+    _content: Optional[EntryContentDocument] = None
+
+    def fromDict(self, ref) -> None:
+        if isinstance(ref, dict):
+            if "name" in ref and ref["name"]:
+                ref["name"] = ref["name"].replace(" > ", "_")
+
+        super().fromDict(ref)
+
+    def fetchContent(self):
+        connection, endpoint, id = self._getConnectionData()
+
+        content, responseError = connection.getEndpoint(endpoint + [id, "content"])
+        if responseError:
+            raise EntityFetchingException(entity=self, responseError=responseError)
+
+        self.content = content
+        self._noContent = False
+
+    @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")
+
+    @property
+    def content(self) -> Optional[EntryContentDocument]:
+        if self._noContent:
+            raise EntityIncompleteException(
+                self,
+                parameterName="content",
+                functionName=f"{self.fetchContent.__name__}()",
+                hasFetchFull=False,
+            )
+        return self._content
+
+    @content.setter
+    def content(self, value):
+        if value:
+            self._noContent = False
+        self._content = EntryContentConverter[EntryContentDocument].convert(
+            value, fieldName="content"
+        )
+
+    @property
+    def alias(self) -> Optional[str]:
+        return self._alias
+
+    @alias.setter
+    def alias(self, value):
+        self._alias = self.checkAndConvertNullable(value, str, "alias")

LOGS/Entities/LabNotebookEntryContent/BasicAttribute.py

@@ -0,0 +1,15 @@
+from typing import Optional
+
+from LOGS.Entity.SerializableContent import SerializableContent
+
+
+class BasicAttribute(SerializableContent):
+    _id: Optional[str] = None
+
+    @property
+    def id(self) -> Optional[str]:
+        return self._id
+
+    @id.setter
+    def id(self, value):
+        self._id = self.checkAndConvertNullable(value, str, "id")

LOGS/Entities/LabNotebookEntryContent/EntityAttribute.py

@@ -0,0 +1,85 @@
+from typing import Optional
+
+from LOGS.Entities.LabNotebookEntryContent.BasicAttribute import BasicAttribute
+from LOGS.Entity.SerializableContent import SerializableClass
+
+
+class EntityAttributeSettings(SerializableClass):
+    showHeader: Optional[bool] = None
+    collapsible: Optional[bool] = None
+    defaultCollapsed: Optional[bool] = None
+
+
+class EntityAttributeAdditionalSettings(SerializableClass):
+    height: Optional[int] = None
+    showViewer: Optional[bool] = None
+
+
+class EntityAttribute(BasicAttribute):
+    _version: Optional[int] = None
+    _entityId: Optional[int] = None
+    _settings: Optional[EntityAttributeSettings] = None
+    _additionalSettings: Optional[EntityAttributeAdditionalSettings] = None
+    _entityUuid: Optional[str] = None
+    _entityTypeId: Optional[str] = None
+    _style: Optional[str] = None
+
+    @property
+    def style(self) -> Optional[str]:
+        return self._style
+
+    @style.setter
+    def style(self, value):
+        self._style = self.checkAndConvertNullable(value, str, "style")
+
+    @property
+    def entityTypeId(self) -> Optional[str]:
+        return self._entityTypeId
+
+    @entityTypeId.setter
+    def entityTypeId(self, value):
+        self._entityTypeId = self.checkAndConvertNullable(value, str, "entityTypeId")
+
+    @property
+    def entityUuid(self) -> Optional[str]:
+        return self._entityUuid
+
+    @entityUuid.setter
+    def entityUuid(self, value):
+        self._entityUuid = self.checkAndConvertNullable(value, str, "entityUuid")
+
+    @property
+    def version(self) -> Optional[int]:
+        return self._version
+
+    @version.setter
+    def version(self, value):
+        self._version = self.checkAndConvertNullable(value, int, "version")
+
+    @property
+    def entityId(self) -> Optional[int]:
+        return self._entityId
+
+    @entityId.setter
+    def entityId(self, value):
+        self._entityId = self.checkAndConvertNullable(value, int, "entityId")
+
+    @property
+    def settings(self) -> Optional[EntityAttributeSettings]:
+        return self._settings
+
+    @settings.setter
+    def settings(self, value):
+        self._settings = self.checkAndConvertNullable(
+            value, EntityAttributeSettings, "settings"
+        )
+
+    @property
+    def additionalSettings(self) -> Optional[EntityAttributeAdditionalSettings]:
+        return self._additionalSettings
+
+    @additionalSettings.setter
+    def additionalSettings(self, value):
+        self._additionalSettings = self.checkAndConvertNullable(
+            value, EntityAttributeAdditionalSettings, "additionalSettings"
+        )

LOGS/Entities/LabNotebookEntryContent/EntryContentBlockquote.py

@@ -0,0 +1,13 @@
+from LOGS.Entities.LabNotebookEntryContent.EntryContentItem import EntryContentItem
+from LOGS.Entities.LabNotebookEntryContent.IEntryContentWithContent import (
+    IEntryContentWithContent,
+)
+from LOGS.Entities.LabNotebookEntryContent.IEntryContentWithTextAttribute import (
+    IEntryContentWithTextAttribute,
+)
+
+
+class EntryContentBlockquote(
+    EntryContentItem, IEntryContentWithContent, IEntryContentWithTextAttribute
+):
+    _type = "blockquote"