logs-py 4.0.7__py3-none-any.whl

LOGS/Entity/__init__.py

@@ -0,0 +1,23 @@
+"""
+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.
+"""
+
+from ..Auxiliary.Exceptions import *
+from .ConnectedEntity import *
+from .Entity import *
+from .EntityConnector import *
+from .EntityIterator import *
+from .EntityMinimal import *
+from .EntityMinimalWithIntId import *
+from .EntityMinimalWithStrId import *
+from .EntityMinimalWithType import *
+from .EntityRequestParameter import *
+from .EntityWithIntId import *
+from .EntityWithStrId import *
+from .SerializableContent import *

LOGS/Interfaces/ICustomFieldValue.py

@@ -0,0 +1,92 @@
+import re
+from typing import TYPE_CHECKING, Any, Optional, cast
+
+from LOGS.Auxiliary.CustomFieldValueTypeChecker import CustomFieldValueTypeChecker
+from LOGS.Auxiliary.Exceptions import EntityNotConnectedException
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Entities.CustomFieldModels import CustomFieldDataType, CustomFieldValueType
+from LOGS.Interfaces.ICustomValue import ITypedCustomValue
+from LOGS.LOGSConnection import LOGSConnection
+
+if TYPE_CHECKING:
+    from LOGS.Entity.ConnectedEntity import ConnectedEntity
+
+
+class ICustomFieldValue(ITypedCustomValue):
+    _type: CustomFieldValueType = CustomFieldValueType.CustomField
+    _valueTypeChecker: CustomFieldValueTypeChecker = cast(
+        CustomFieldValueTypeChecker, None
+    )
+    _newLineRe = re.compile(r"[\n\r\t\b\f]+")
+    _connection: Optional[LOGSConnection] = None
+
+    _id: Optional[int] = None
+    _dataType: CustomFieldDataType
+    _value: Optional[Any] = None
+    _name: Optional[str] = None
+
+    def __init__(self, ref=None, dataType: Optional[CustomFieldDataType] = None):
+        if not dataType:
+            raise Exception("Data type is not set")
+        self._dataType = dataType
+        self._setTypeChecker()
+        super().__init__(ref)
+
+    def _getConnection(self):
+        if not self._connection:
+            raise EntityNotConnectedException(cast("ConnectedEntity", self))
+        return self._connection
+
+    def _setTypeChecker(self):
+        self._valueTypeChecker = CustomFieldValueTypeChecker(
+            self._dataType, self._getConnection()
+        )
+
+    def _contentToString(self) -> str:
+        if self._valueTypeChecker._isArrayType:
+            v = [str(f) for f in self.value] if self.value is not None else []
+            t = ", ".join(v)
+        else:
+            t = str(self.value) if self.value is not None else ""
+        t = self._newLineRe.sub(" ", t)
+        return Tools.truncString(t, 100)
+
+    def __str__(self):
+        id = f" [{'' + self._dataType.name + ']' if self._dataType else ''}{' ID:' + str(self.id) if self.id else ''}"
+        return f"<{type(self).__name__}{id}>"
+
+    @property
+    def identifier(self):
+        name = (
+            f" '{getattr(self, 'name')}'"
+            if hasattr(self, "name") and getattr(self, "name")
+            else ""
+        )
+        return "%s(id:%s)%s" % (
+            type(self).__name__,
+            str(self.id),
+            name,
+        )
+
+    @property
+    def id(self) -> Optional[int]:
+        return self._id
+
+    @property
+    def dataType(self) -> Optional[CustomFieldDataType]:
+        return self._dataType
+
+    @property
+    def value(self) -> Optional[Any]:
+        return self._value
+
+    @value.setter
+    def value(self, value):
+        if not self._dataType:
+            raise Exception("Data type is not set")
+
+        self._value = self._valueTypeChecker.checkAndConvert(value, type(self).__name__)
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name

LOGS/Interfaces/ICustomSectionValue.py

@@ -0,0 +1,161 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union, cast
+
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Entities.CustomFieldModels import CustomFieldValueType
+from LOGS.Interfaces.ICustomFieldValue import ICustomFieldValue
+from LOGS.Interfaces.ICustomValue import ITypedCustomValue
+
+if TYPE_CHECKING:
+    pass
+
+
+class ICustomSectionValue(ITypedCustomValue):
+    _noSerialize: List[str] = ["fieldNames"]
+
+    _type: CustomFieldValueType = CustomFieldValueType.CustomTypeSection
+    _customTypeId: int = cast(int, None)
+    _sectionIndex: int = cast(int, None)
+
+    _fieldNames: List[str] = []
+    _fieldTypes: Dict[str, Type[ICustomFieldValue]] = {}
+    _fieldIds: Dict[int, str] = {}
+    _name: Optional[str] = None
+
+    def __init__(self, ref=None):
+        for fieldName in self._fieldNames:
+            setattr(self, "_" + fieldName, self._fieldTypes[fieldName]())
+        super().__init__(ref)
+
+    def fromDict(self, ref) -> None:
+        if isinstance(ref, dict) and "content" in ref:
+            content = ref["content"]
+            del ref["content"]
+
+        super().fromDict(ref)
+
+        if content is not None:
+            if not isinstance(content, list):
+                raise ValueError(
+                    f"Invalid content format. (Expected a 'list' got '{type(content).__name__}')"
+                )
+            for i, c in enumerate(content):
+                if not isinstance(c, dict):
+                    raise ValueError(
+                        f"Invalid content item {i} format. (Expected a 'dict' got '{type(c).__name__}')"
+                    )
+                if "value" not in c:
+                    continue
+                if "id" not in c:
+                    raise ValueError(f"Content item {i} is missing the 'id' field.")
+                fieldId = Tools.checkAndConvert(
+                    c["id"], int, f"content[{i}].id", allowNone=False
+                )
+                self.setField(fieldId, c["value"])
+
+    def toDict(self) -> Dict[str, Any]:
+        result = super().toDict()
+        content = []
+        for name in self._fieldNames:
+            field = self.getCustomField(name)
+            if field is not None:
+                content.append(field.toDict() if hasattr(field, "toDict") else field)
+        result["content"] = content
+        return result
+
+    @classmethod
+    def _generateId(cls, customTypeId: int, sectionIndex: int):
+        return f"{customTypeId}.{sectionIndex}"
+
+    def _getFieldNameFromId(self, fieldId: int) -> str:
+        if fieldId not in self._fieldIds:
+            raise AttributeError(f"Unknown field ID '{type(self).__name__}.{fieldId}'.")
+        return self._fieldIds[fieldId]
+
+    def setField(self, fieldNameOrId: Union[str, int], value):
+        fieldName = (
+            self._getFieldNameFromId(fieldNameOrId)
+            if isinstance(fieldNameOrId, int)
+            else fieldNameOrId
+        )
+
+        if fieldName not in self._fieldNames:
+            raise AttributeError(f"Unknown field '{type(self).__name__}.{fieldName}'.")
+        f = self.getCustomField(fieldName)
+        if f is not None:
+            f.value = value
+
+    def getField(self, fieldNameOrId: Union[str, int]):
+        fieldName = (
+            self._getFieldNameFromId(fieldNameOrId)
+            if isinstance(fieldNameOrId, int)
+            else fieldNameOrId
+        )
+
+        if fieldName not in self._fieldNames:
+            raise AttributeError(f"Unknown field '{type(self).__name__}.{fieldName}'.")
+        f = self.getCustomField(fieldName)
+        return f.value if f is not None else None
+
+    def _getCustomFieldByName(self, fieldName: str) -> Optional[ICustomFieldValue]:
+        return getattr(self, "_" + fieldName)
+
+    def getCustomField(self, fieldName: str) -> Optional[ICustomFieldValue]:
+        if fieldName not in self._fieldNames:
+            raise AttributeError(
+                f"Unknown custom field '{type(self).__name__}.{fieldName}'."
+            )
+        return self._getCustomFieldByName(fieldName)
+
+    def _contentToString(self, indentation: int = 0, hideNone: bool = False) -> str:
+        s = ""
+        for name in self._fieldNames:
+            field = self.getCustomField(name)
+            if field is not None:
+                content = field._contentToString()
+                if not content and hideNone:
+                    continue
+                s += f"{self._indentationString * indentation}{name} = {content}\n"
+        return s
+
+    def __str__(self):
+        id1 = f"typeID:{self._customTypeId}" if self._customTypeId is not None else ""
+        id2 = f"index:{self._sectionIndex}" if self._sectionIndex is not None else ""
+        id = f"{id1}{' ' if id2 else ''}{id2}; " if id1 or id2 else ""
+        return f"<{type(self).__name__} [{id}{Tools.numberPlural('field' , len(self._fieldNames))}]>"
+
+    def customField(self, nameOrId) -> Optional[ICustomFieldValue]:
+        for name in self._fieldNames:
+            value = self._getCustomFieldByName(name)
+            if isinstance(nameOrId, int):
+                if value is not None and value.id == nameOrId:
+                    return value
+            else:
+                if value is not None and value.name == str(nameOrId):
+                    return value
+
+        return None
+
+    @classmethod
+    def getId(cls) -> str:
+        return cls._generateId(cls._customTypeId, cls._sectionIndex)
+
+    @property
+    def customFields(self) -> List[ICustomFieldValue]:
+        result = []
+        for name in self._fieldNames:
+            value = self._getCustomFieldByName(name)
+            if value is not None:
+                result.append(value)
+        return result
+
+    @property
+    def fieldNames(self) -> List[str]:
+        return self._fieldNames
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        self._name = self.checkAndConvertNullable(value, str, "name")

LOGS/Interfaces/ICustomTypeValue.py

@@ -0,0 +1,152 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union, cast
+
+from LOGS.Interfaces.ICustomFieldValue import ICustomFieldValue
+from LOGS.Interfaces.ICustomSectionValue import ICustomSectionValue
+from LOGS.Interfaces.ICustomValue import ICustomValue
+
+if TYPE_CHECKING:
+    pass
+
+
+class ICustomTypeValue(ICustomValue):
+    _id: Optional[int] = None
+    _name: Optional[str] = None
+
+    _fieldNames: List[str] = []
+    _fieldTypes: Dict[str, Type[ICustomFieldValue]] = {}
+    _fieldIds: Dict[int, str] = {}
+
+    def __init__(
+        self,
+        ref=None,
+    ):
+        for fieldName in self._fieldNames:
+            setattr(self, "_" + fieldName, self._fieldTypes[fieldName]())
+        if not isinstance(ref, dict):
+            ref = {"content": ref}
+        super().__init__(ref)
+
+    def fromDict(self, ref) -> None:
+        if isinstance(ref, dict) and "content" in ref:
+            content = ref["content"]
+            del ref["content"]
+
+        super().fromDict(ref)
+
+        if content is not None:
+            if not isinstance(content, list):
+                raise ValueError(
+                    f"Invalid content format. (Expected a 'list' got '{type(content).__name__}')"
+                )
+            for i, c in enumerate(content):
+                if not isinstance(c, dict):
+                    raise ValueError(
+                        f"Invalid content item {i} format. (Expected a 'dict' got '{type(c).__name__}')"
+                    )
+                if "type" not in c:
+                    raise ValueError(f"Content item {i} is missing the 'type' field.")
+                if c["type"] != "CustomTypeSection" or "content" not in c:
+                    continue
+
+                s = self.getSection(i)
+                if s is not None:
+                    s.override(c)
+
+    def toDict(self) -> Dict[str, Any]:
+        result = super().toDict()
+        content = []
+        for name in self._fieldNames:
+            field = self.getSection(name)
+            if field is not None:
+                content.append(field.toDict() if hasattr(field, "toDict") else field)
+        # print("content:", content)
+        return cast(Any, content)
+
+    def __str__(self):
+        id = f" [ID: {self.id}]" if self.id else ""
+        return f"<{type(self).__name__}{id}>"
+
+    def _contentToString(self, indentation: int = 0, hideNone: bool = False) -> str:
+        tab = self._indentationString * indentation
+        s = ""
+        for name in self._fieldNames:
+            section = self.getSection(name)
+            if not section and hideNone:
+                continue
+            content = ""
+            if section is not None:
+                content = section._contentToString(indentation + 1, hideNone=hideNone)
+            if not content and hideNone:
+                continue
+            s += f"{tab}{name}:\n{content}"
+        return s
+
+    def _getFieldNameFromId(self, fieldId: str) -> str:
+        if fieldId in self._fieldIds:
+            return self._fieldIds[fieldId]
+        return fieldId
+
+    def getField(self, fieldNameOrId: str):
+        fieldName = self._getFieldNameFromId(fieldNameOrId)
+
+        if fieldName not in self._fieldNames:
+            raise AttributeError(f"Unknown field '{type(self).__name__}.{fieldName}'.")
+        return self.getSection(fieldName)
+
+    def _getSectionByName(self, sectionName: str) -> Optional[ICustomSectionValue]:
+        return getattr(self, "_" + sectionName)
+
+    def getSection(
+        self, sectionIndexOrFieldId: Union[str, int]
+    ) -> Optional[ICustomSectionValue]:
+
+        if isinstance(sectionIndexOrFieldId, int):
+            if self.id is None:
+                raise ValueError(f"Section with index {sectionIndexOrFieldId} unknown")
+            fieldId = ICustomSectionValue._generateId(self.id, sectionIndexOrFieldId)
+        else:
+            fieldId = sectionIndexOrFieldId
+
+        fieldName = self._getFieldNameFromId(fieldId)
+        if fieldName not in self._fieldNames:
+            raise AttributeError(
+                f"Section with index or name '{sectionIndexOrFieldId}' unknown."
+            )
+        return self._getSectionByName(fieldName)
+
+    def printFieldValues(self, hideNone: bool = False):
+
+        s = f"{type(self).__name__}"
+
+        customFields = self.customFields
+        for field in customFields:
+            if hideNone and (field.value is None or field.value == ""):
+                continue
+            s += f"\n{self._indentationString}{field.name} [{field.id}] = {field.value}"
+        print(s)
+
+    def customField(self, nameOrId) -> Optional[ICustomFieldValue]:
+        for name in self._fieldNames:
+            section = self._getSectionByName(name)
+            if section is not None:
+                field = section.customField(nameOrId)
+                if field is not None:
+                    return field
+        return None
+
+    @property
+    def customFields(self) -> List[ICustomFieldValue]:
+        result = []
+        for name in self._fieldNames:
+            section = self._getSectionByName(name)
+            if section is not None:
+                result.extend(section.customFields)
+        return result
+
+    @property
+    def id(self) -> Optional[int]:
+        return self._id
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name

LOGS/Interfaces/ICustomValue.py

@@ -0,0 +1,28 @@
+from typing import TYPE_CHECKING, cast
+
+from LOGS.Auxiliary.Exceptions import IllegalFieldValueException
+from LOGS.Entities.CustomFieldModels import CustomFieldValueType
+from LOGS.Entity.SerializableContent import SerializableContent
+
+if TYPE_CHECKING:
+    pass
+
+
+class ICustomValue(SerializableContent):
+    _indentationString: str = "  "
+
+
+class ITypedCustomValue(ICustomValue):
+    _type: CustomFieldValueType = cast(CustomFieldValueType, None)
+
+    @property
+    def type(self) -> CustomFieldValueType:
+        return self._type
+
+    @type.setter
+    def type(self, value):
+        value = self.checkAndConvert(value, CustomFieldValueType, "type")
+        if value != self._type:
+            raise IllegalFieldValueException(
+                self, "type", value, f"Only value '{self._type}' allowed."
+            )

LOGS/Interfaces/IEntityInterface.py

@@ -0,0 +1,7 @@
+class IEntityInterface:
+    def _getEntityConnection(self):
+        from LOGS.Entity.ConnectedEntity import ConnectedEntity
+
+        if isinstance(self, ConnectedEntity):
+            return self._getConnection()
+        return None

LOGS/Interfaces/IEntryRecord.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import TYPE_CHECKING, List, Optional
+
+from LOGS.Auxiliary import Tools
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+if TYPE_CHECKING:
+    from LOGS.Entities.PersonMinimal import PersonMinimal
+
+
+@dataclass
+class IEnteredOnRequest:
+    enteredFrom: Optional[datetime] = None
+    enteredTo: Optional[datetime] = None
+
+
+class IEnteredByRequest:
+    createdByIds: Optional[List[int]]
+
+
+@dataclass
+class IEntryRecordRequest(IEnteredOnRequest, IEnteredByRequest):
+    pass
+
+
+class IEnteredOn(IEntityInterface):
+    _enteredOn: Optional[datetime] = None
+
+    @property
+    def enteredOn(self) -> Optional[datetime]:
+        return self._enteredOn
+
+    @enteredOn.setter
+    def enteredOn(self, value):
+        self._enteredOn = Tools.checkAndConvert(
+            value, datetime, "enteredOn", allowNone=True
+        )
+
+
+class IEnteredBy(IEntityInterface):
+    _enteredBy: Optional["PersonMinimal"] = None
+
+    @property
+    def enteredBy(self) -> Optional["PersonMinimal"]:
+        return self._enteredBy
+
+    @enteredBy.setter
+    def enteredBy(self, value):
+        self._enteredBy = MinimalModelGenerator.MinimalFromSingle(
+            value, "PersonMinimal", "enteredBy", connection=self._getEntityConnection()
+        )
+
+
+class IEntryRecord(IEnteredOn, IEnteredBy):
+    pass

LOGS/Interfaces/IHierarchicalEntity.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional
+
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+if TYPE_CHECKING:
+    from LOGS.Entities.InventoryItemMinimal import InventoryItemMinimal
+
+
+@dataclass
+class IHierarchicalEntityRequest:
+    childrenOfParentIds: Optional[List[int]] = None
+    descendantsOfIds: Optional[List[int]] = None
+    excludeHierarchyChildren: Optional[bool] = None
+    isHierarchyRoot: Optional[bool] = None
+
+
+class IHierarchicalEntity(IEntityInterface):
+    _ancestors: Optional[List["InventoryItemMinimal"]] = None
+    _parent: Optional["InventoryItemMinimal"] = None
+
+    @property
+    def ancestors(self) -> Optional[List["InventoryItemMinimal"]]:
+        return self._ancestors
+
+    @ancestors.setter
+    def ancestors(self, value):
+        self._ancestors = MinimalModelGenerator.MinimalFromList(
+            value, "InventoryItemMinimal", "ancestors", self._getEntityConnection()
+        )
+
+    @property
+    def parent(self) -> Optional["InventoryItemMinimal"]:
+        return self._parent
+
+    @parent.setter
+    def parent(self, value):
+        self._parent = MinimalModelGenerator.MinimalFromSingle(
+            value, "InventoryItemMinimal", "parent", self._getEntityConnection()
+        )

LOGS/Interfaces/IHierarchyType.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional
+
+from LOGS.Auxiliary import Tools
+from LOGS.Entity.EntityMinimalWithIntId import EntityMinimalWithIntId
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+if TYPE_CHECKING:
+    pass
+
+
+@dataclass
+class IHierarchyTypeRequest:
+    childrenOfParentIds: Optional[List[int]] = None
+    descendantsOfIds: Optional[List[int]] = None
+    isRoot: Optional[List[bool]] = None
+
+
+class IHierarchyType(IEntityInterface):
+    _inventoryName: Optional[str]
+    _isHierarchyRoot: Optional[bool]
+    _rootHierarchy: Optional[EntityMinimalWithIntId]
+    _parentTypes: Optional[List[EntityMinimalWithIntId]]
+
+    @property
+    def inventoryName(self) -> Optional[str]:
+        return self._inventoryName
+
+    @inventoryName.setter
+    def inventoryName(self, value):
+        self._inventoryName = Tools.checkAndConvert(
+            value, str, "inventoryName", allowNone=True
+        )
+
+    @property
+    def isHierarchyRoot(self) -> Optional[bool]:
+        return self._isHierarchyRoot
+
+    @isHierarchyRoot.setter
+    def isHierarchyRoot(self, value):
+        self._isHierarchyRoot = Tools.checkAndConvert(
+            value, bool, "isHierarchyRoot", allowNone=True
+        )
+
+    @property
+    def rootHierarchy(self) -> Optional[EntityMinimalWithIntId]:
+        return self._rootHierarchy
+
+    @rootHierarchy.setter
+    def rootHierarchy(self, value):
+        self._rootHierarchy = Tools.checkAndConvert(
+            value, EntityMinimalWithIntId, "rootHierarchy", allowNone=True
+        )
+
+    @property
+    def parentTypes(self) -> Optional[List[EntityMinimalWithIntId]]:
+        return self._parentTypes
+
+    @parentTypes.setter
+    def parentTypes(self, value):
+        self._parentTypes = Tools.checkListAndConvert(
+            value, EntityMinimalWithIntId, "parentTypes", allowNone=True
+        )

LOGS/Interfaces/ILockableEntity.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import TYPE_CHECKING, List, Optional, Union
+
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+if TYPE_CHECKING:
+    from LOGS.Entities.PersonMinimal import PersonMinimal
+
+
+@dataclass
+class ILockableEntityRequest:
+    lockedByIds: Optional[List[int]] = None
+    lockedFrom: Optional[datetime] = None
+    lockedTo: Optional[datetime] = None
+    isLocked: Optional[bool] = None
+
+
+class ILockableEntity(IEntityInterface):
+    _lockedBy: Optional["PersonMinimal"] = None
+    _lockedOn: Optional[datetime] = None
+    _isLocked: Optional[bool] = None
+
+    @property
+    def lockedBy(self) -> Optional["PersonMinimal"]:
+        return self._lockedBy
+
+    @lockedBy.setter
+    def lockedBy(self, value):
+        self._lockedBy = MinimalModelGenerator.MinimalFromSingle(
+            value, "PersonMinimal", "lockedBy", self._getEntityConnection()
+        )
+
+    @property
+    def lockedOn(self) -> Optional[datetime]:
+        return self._lockedOn
+
+    @lockedOn.setter
+    def lockedOn(self, value: Optional[Union[datetime, dict]]):
+        self._lockedOn = Tools.checkAndConvert(
+            value, datetime, "lockedOn", allowNone=True
+        )
+
+    @property
+    def isLocked(self) -> Optional[bool]:
+        return self._isLocked
+
+    @isLocked.setter
+    def isLocked(self, value: Optional[bool]):
+        self._isLocked = Tools.checkAndConvert(value, bool, "isLocked", allowNone=True)