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

LOGS/Entities/FormatFormat.py

@@ -5,10 +5,13 @@ from LOGS.Entity.EntityWithStrId import EntityWithStrId
 from LOGS.Interfaces.INamedEntity import INamedEntity
 
 
-@Endpoint("formats")
+@Endpoint("parser_formats")
 class FormatFormat(INamedEntity, EntityWithStrId):
+
     _description: Optional[str]
     _formatVersion: Optional[List[str]]
+    _isCustom: bool
+    _hasVisualization: bool
 
     @property
     def description(self) -> Optional[str]:
@@ -27,3 +30,21 @@ class FormatFormat(INamedEntity, EntityWithStrId):
         self._formatVersion = self.checkListAndConvertNullable(
             value, str, "formatVersion"
         )
+
+    @property
+    def isCustom(self) -> Optional[bool]:
+        return self._isCustom
+
+    @isCustom.setter
+    def isCustom(self, value):
+        self._isCustom = self.checkAndConvertNullable(value, bool, "isCustom")
+
+    @property
+    def hasVisualization(self) -> Optional[bool]:
+        return self._hasVisualization
+
+    @hasVisualization.setter
+    def hasVisualization(self, value):
+        self._hasVisualization = self.checkAndConvertNullable(
+            value, bool, "hasVisualization"
+        )

LOGS/Entities/FormatFormatRequestParameter.py

@@ -1,8 +1,9 @@
 from dataclasses import dataclass
 
 from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Interfaces.IPermissionedEntity import IPermissionedEntityRequest
 
 
 @dataclass
-class FormatFormatRequestParameter(EntityRequestParameter):
+class FormatFormatRequestParameter(EntityRequestParameter, IPermissionedEntityRequest):
     pass

LOGS/Entities/FormatFormats.py

@@ -4,7 +4,7 @@ from LOGS.Entities.FormatFormatRequestParameter import FormatFormatRequestParame
 from LOGS.Entity.EntityIterator import EntityIterator
 
 
-@Endpoint("formats")
+@Endpoint("parser_formats")
 class FormatFormats(EntityIterator[FormatFormat, FormatFormatRequestParameter]):
     """LOGS connected class FormatFormat iterator"""
 

LOGS/Entities/FormattedTable/DatatypeFormattedTable.py

@@ -0,0 +1,135 @@
+import sys
+from typing import Dict, List, Literal, Optional, Union
+
+from LOGS.Entities.FormattedTable.DatatypeFormattedTableCell import (
+    DatatypeFormattedTableCell,
+)
+from LOGS.Entity.SerializeableContent import SerializeableContent
+
+_VTypeType = Literal["int", "float", "str", "bool"]
+
+
+class DatatypeFormattedTable(SerializeableContent):
+    _type: str = "formatted_table"
+    _name: Optional[str] = None
+    _id = ""
+
+    _cells: List[DatatypeFormattedTableCell] = []
+
+    _rowRange: List[int] = [sys.maxsize, -1]
+    _columnRange: List[int] = [sys.maxsize, -1]
+
+    _cellIds: Dict[str, int] = {}
+
+    _fixedRow: Optional[int] = None
+    _fixedColumn: Optional[int] = None
+
+    def appendCell(
+        self,
+        cell: Union[_VTypeType, DatatypeFormattedTableCell],
+        row: int = -1,
+        column: int = -1,
+    ) -> DatatypeFormattedTableCell:
+        c = self.checkAndConvert(
+            cell, fieldName="cell", fieldType=DatatypeFormattedTableCell
+        )
+        if row >= 0:
+            c.row = row
+        if column >= 0:
+            c.column = column
+
+        id = c.id
+        index = self.getCell(id)
+        if index >= 0:
+            self.cells[index] = c
+        else:
+            self._cellIds[id] = len(self.cells)
+            self.cells.append(c)
+
+        # self.reorganizeCells()
+
+        return c
+
+    def getCell(self, id: str) -> int:
+        if id in self._cellIds:
+            return self._cellIds[id]
+        return -1
+
+    # def addCellId(self, cell: DatatypeFormattedTableCell):
+    #     self.cells.sort(key=lambda c: (c.row, c.column))
+    #     self._cellIds = {c.id: i for i, c in enumerate(self.cells)}
+    #     self._cellIds[cell.id] = cell
+
+    def reorganizeCells(self):
+        self.cells.sort(key=lambda c: c.column)
+        self._columnRange = [self.cells[0].column, self.cells[-1].column]
+        self.cells.sort(key=lambda c: (c.row, c.column))
+        self._rowRange = [self.cells[0].row, self.cells[-1].row]
+        self._cellIds = {c.id: i for i, c in enumerate(self.cells)}
+
+    def toDict(self, validate=False):
+        self.reorganizeCells()
+        return super().toDict()
+
+    @property
+    def type(self) -> str:
+        return self._type
+
+    @type.setter
+    def type(self, value):
+        self._type = value
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @id.setter
+    def id(self, value):
+        self._id = value
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        self._name = value
+
+    @property
+    def cells(self) -> List[DatatypeFormattedTableCell]:
+        return self._cells
+
+    @cells.setter
+    def cells(self, value):
+        self._cells = self.checkListAndConvert(
+            value, fieldName="cells", fieldType=DatatypeFormattedTableCell
+        )
+        self.reorganizeCells()
+
+    @property
+    def rowRange(self) -> List[int]:
+        return self._rowRange
+
+    @property
+    def columnRange(self) -> List[int]:
+        return self._columnRange
+
+    @property
+    def fixedRow(self) -> Optional[int]:
+        return self._fixedRow
+
+    @fixedRow.setter
+    def fixedRow(self, value):
+        self._fixedRow = self.checkAndConvert(
+            value, fieldName="fixedRow", fieldType=int, allowNone=True
+        )
+
+    @property
+    def fixedColumn(self) -> Optional[int]:
+        return self._fixedColumn
+
+    @fixedColumn.setter
+    def fixedColumn(self, value):
+        self._fixedColumn = self.checkAndConvert(
+            value, fieldName="fixedColumn", fieldType=int, allowNone=True
+        )

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.SerializeableContent import SerializeableContent
+
+_VTypeType = Literal["int", "float", "str", "bool"]
+_ValueType = Union[str, int, float, bool, None]
+
+
+class DatatypeFormattedTableCell(SerializeableContent):
+    __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.SerializeableContent import SerializeableClass
+
+
+class DatatypeFormattedTableSettings(SerializeableClass):
+    _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/ILiterarTypedEntity.py

@@ -0,0 +1,19 @@
+from typing import Any, Optional, cast
+
+from LOGS.Auxiliary.Exceptions import IllegalFieldValueException
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+
+class ILiterarTypedEntity(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/Instrument.py

@@ -9,7 +9,7 @@ from LOGS.Interfaces.ICreationRecord import ICreatedOn
 from LOGS.Interfaces.IModificationRecord import IModifiedOn
 from LOGS.Interfaces.INamedEntity import INamedEntity
 from LOGS.Interfaces.IOwnedEntity import IOwnedEntity
-from LOGS.Interfaces.IPermissionedEntity import IPermissionedEntity
+from LOGS.Interfaces.IPermissionedEntity import GenericPermissionEntity
 from LOGS.Interfaces.IRelatedEntity import IRelatedEntity
 from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
 from LOGS.LOGSConnection import LOGSConnection
@@ -24,9 +24,9 @@ class Instrument(
     IUniqueEntity,
     ICreatedOn,
     IModifiedOn,
-    IPermissionedEntity,
+    GenericPermissionEntity,
 ):
-    _relationType = type(InstrumentRelations)
+    _relationType = InstrumentRelations
 
     _serialnumber: Optional[str]
     _room: Optional[str]

LOGS/Entities/Inventories.py

@@ -0,0 +1,12 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.Inventory import Inventory
+from LOGS.Entities.InventoryRequestParameter import InventoryRequestParameter
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("inventories")
+class Inventories(EntityIterator[Inventory, InventoryRequestParameter]):
+    """LOGS connected Inventories iterator"""
+
+    _generatorType = Inventory
+    _parameterType = InventoryRequestParameter

LOGS/Entities/Inventory.py

@@ -0,0 +1,95 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalFromList, MinimalFromSingle
+from LOGS.Entities.InventoryRelations import InventoryRelations
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
+from LOGS.Interfaces.ICreationRecord import ICreationRecord
+from LOGS.Interfaces.IHierarchyType import IHierarchyType
+from LOGS.Interfaces.IModificationRecord import IModificationRecord
+from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.Interfaces.IPermissionedEntity import GenericPermissionEntity
+from LOGS.Interfaces.IProjectBased import IProjectBased
+from LOGS.Interfaces.IRelatedEntity import IRelatedEntity
+from LOGS.Interfaces.ISoftDeletable import ISoftDeletable
+from LOGS.Interfaces.ITypedEntity import ITypedEntity
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
+
+if TYPE_CHECKING:
+    from LOGS.Entities.InventoryMinimal import InventoryMinimal
+
+
+@Endpoint("inventories")
+class Inventory(
+    IEntityWithIntId,
+    INamedEntity,
+    IUniqueEntity,
+    ICreationRecord,
+    IModificationRecord,
+    ISoftDeletable,
+    IRelatedEntity[InventoryRelations],
+    ITypedEntity,
+    IProjectBased,
+    IHierarchyType,
+    GenericPermissionEntity,
+):
+    _relationType = InventoryRelations
+
+    _rootCustomType: Optional["InventoryMinimal"] = None
+    _isRootItem: Optional[bool] = None
+    _isHierarchyItem: Optional[bool] = None
+    _isDeleted: Optional[bool] = None
+    _ancestors: Optional[List["InventoryMinimal"]] = None
+    _parent: Optional["InventoryMinimal"] = None
+
+    @property
+    def rootCustomType(self) -> Optional["InventoryMinimal"]:
+        return self._rootCustomType
+
+    @rootCustomType.setter
+    def rootCustomType(self, value):
+        self._rootCustomType = MinimalFromSingle(
+            value, "InventoryMinimal", "rootCustomType"
+        )
+
+    @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 isDeleted(self) -> Optional[bool]:
+        return self._isDeleted
+
+    @isDeleted.setter
+    def isDeleted(self, value):
+        self._isDeleted = self.checkAndConvertNullable(value, bool, "isDeleted")
+
+    @property
+    def ancestors(self) -> Optional[List["InventoryMinimal"]]:
+        return self._ancestors
+
+    @ancestors.setter
+    def ancestors(self, value):
+        self._ancestors = MinimalFromList(value, "InventoryMinimal", "ancestors")
+
+    @property
+    def parent(self) -> Optional["InventoryMinimal"]:
+        return self._parent
+
+    @parent.setter
+    def parent(self, value):
+        self._parent = MinimalFromSingle(value, "InventoryMinimal", "parent")

LOGS/Entities/InventoryMinimal.py

@@ -0,0 +1,20 @@
+from typing import Optional
+
+from LOGS.Auxiliary.Decorators import FullModel
+from LOGS.Entities.Inventory import Inventory
+from LOGS.Entity.EntityMinimalWithIntId import EntityMinimalWithIntId
+
+
+@FullModel(Inventory)
+class InventoryMinimal(EntityMinimalWithIntId[Inventory]):
+    _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
+        )

LOGS/Entities/InventoryRelations.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:
+    pass
+
+
+class InventoryRelations(EntityRelations):
+    """Relations of a Inventory with other entities"""
+
+    _labNotebookEntries: Optional[EntityRelation] = None
+
+    @property
+    def labNotebookEntries(self) -> Optional[EntityRelation]:
+        return self._labNotebookEntries
+
+    @labNotebookEntries.setter
+    def labNotebookEntries(self, value):
+        self._labNotebookEntries = self.checkAndConvertNullable(
+            value, EntityRelation, "labNotebookEntries"
+        )

LOGS/Entities/InventoryRequestParameter.py

@@ -0,0 +1,53 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import List, Optional
+
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Interfaces.ICreationRecord import ICreationRecordRequest
+from LOGS.Interfaces.IHierarchyType import IHierarchyTypeRequest
+from LOGS.Interfaces.IModificationRecord import IModificationRecordRequest
+from LOGS.Interfaces.IPaginationRequest import IPaginationRequest
+from LOGS.Interfaces.IPermissionedEntity import IPermissionedEntityRequest
+from LOGS.Interfaces.IProjectBased import IProjectBasedRequest
+from LOGS.Interfaces.ISoftDeletable import ISoftDeletableRequest
+from LOGS.Interfaces.ITypedEntity import ITypedEntityRequest
+
+
+class InventoryOrder(Enum):
+    ID_ASC = "ID_ASC"
+    ID_DESC = "ID_DESC"
+    NAME_ASC = "NAME_ASC"
+    NAME_DESC = "NAME_DESC"
+    CREATED_ON_ASC = "CREATED_ON_ASC"
+    CREATED_ON_DESC = "CREATED_ON_DESC"
+    CREATED_BY_ASC = "CREATED_BY_ASC"
+    CREATED_BY_DESC = "CREATED_BY_DESC"
+    MODIFIED_ON_ASC = "MODIFIED_ON_ASC"
+    MODIFIED_ON_DESC = "MODIFIED_ON_DESC"
+    MODIFIED_BY_ASC = "MODIFIED_BY_ASC"
+    MODIFIED_BY_DESC = "MODIFIED_BY_DESC"
+    NUMBER_OF_ITEMS_ASC = "NUMBER_OF_ITEMS_ASC"
+    NUMBER_OF_ITEMS_DESC = "NUMBER_OF_ITEMS_DESC"
+    TYPE_ASC = "TYPE_ASC"
+    TYPE_DESC = "TYPE_DESC"
+    INVENTORY_NAME_ASC = "INVENTORY_NAME_ASC"
+    INVENTORY_NAME_DESC = "INVENTORY_NAME_DESC"
+
+
+@dataclass
+class InventoryRequestParameter(
+    EntityRequestParameter[InventoryOrder],
+    IPaginationRequest,
+    ICreationRecordRequest,
+    IModificationRecordRequest,
+    ISoftDeletableRequest,
+    ITypedEntityRequest,
+    IHierarchyTypeRequest,
+    IProjectBasedRequest,
+    IPermissionedEntityRequest,
+):
+    childrenOfParentIds: Optional[List[int]] = None
+    descendantsOfIds: Optional[List[int]] = None
+    excludeHierarchyChildren: Optional[bool] = None
+    isHierarchyRoot: Optional[bool] = None
+    inventoryIds: Optional[List[int]] = None

LOGS/Entities/LabNotebook.py

@@ -0,0 +1,37 @@
+from typing import Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.LabNotebookModels import LabNotebookStatus
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
+from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.Interfaces.IPermissionedEntity import GenericPermissionEntity
+from LOGS.Interfaces.IProjectBased import IProjectBased
+from LOGS.Interfaces.IVersionedEntity import IVersionedEntity
+
+
+@Endpoint("lab_notebooks")
+class LabNotebook(
+    IEntityWithIntId,
+    INamedEntity,
+    GenericPermissionEntity,
+    IVersionedEntity,
+    IProjectBased,
+):
+    _description: Optional[str] = None
+    _status: Optional[LabNotebookStatus] = None
+
+    @property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @description.setter
+    def description(self, value: str):
+        self._description = self.checkAndConvertNullable(value, str, "description")
+
+    @property
+    def status(self) -> Optional[LabNotebookStatus]:
+        return self._status
+
+    @status.setter
+    def status(self, value: str):
+        self._status = self.checkAndConvertNullable(value, LabNotebookStatus, "status")