logs-py 4.0.7__py3-none-any.whl

LOGS/Auxiliary/CustomSectionClassGenerator.py

@@ -0,0 +1,113 @@
+from base64 import b64encode
+from typing import TYPE_CHECKING, Any, Dict, Optional, Type, cast
+
+from LOGS.Auxiliary.CheckClassName import CheckClassName
+from LOGS.Auxiliary.CustomFieldClassGenerator import CustomFieldClassGenerator
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Interfaces.ICustomSectionValue import ICustomSectionValue
+
+if TYPE_CHECKING:
+    from LOGS.Entities.CustomTypeSection import CustomTypeSection
+    from LOGS.LOGSConnection import LOGSConnection
+
+
+class CustomSectionClassGenerator:
+
+    _classCache: Dict[str, Type["ICustomSectionValue"]] = {}
+
+    @classmethod
+    def _getCacheKey(cls, customTypeSection: str, connection: "LOGSConnection") -> str:
+        url = connection.getEndpointUrl(["custom_type_sections", customTypeSection])
+        return b64encode(url.encode()).decode()
+
+    @classmethod
+    def generate(
+        cls,
+        section: "CustomTypeSection",
+        customTypeId: int,
+        sectionIndex: int,
+        connection: "LOGSConnection",
+        fieldName: Optional[str] = None,
+    ) -> Type["ICustomSectionValue"]:
+
+        if not customTypeId >= 0:
+            raise ValueError(
+                f"Section customTypeId is missing for section in field '{fieldName}'."
+            )
+
+        if not sectionIndex >= 0:
+            raise ValueError(
+                f"Section index is missing for section {sectionIndex} in field '{fieldName}'."
+            )
+
+        id = ICustomSectionValue._generateId(customTypeId, sectionIndex)
+        cacheId = cls._getCacheKey(id, connection)
+        if cacheId in cls._classCache:
+            return cls._classCache[cacheId]
+
+        customFields = (
+            [
+                CustomFieldClassGenerator.generate(
+                    customFieldId=c.id, fieldName=fieldName, connection=connection
+                )
+                for c in section.customFields
+                if c and c.id
+            ]
+            if section.customFields
+            else []
+        )
+
+        name = (
+            CheckClassName.sanitizeClassName(section.name)
+            if section.name
+            else f"Section_TypeID{customTypeId}_Index{sectionIndex}"
+        )
+
+        module = ".".join(
+            ICustomSectionValue.__module__.split(".")[:-1]
+            + ["GeneratedCustomSectionValues"],
+        )
+
+        class CustomFieldProperty:
+            def __init__(self, name: str):
+                self.name = name
+
+            def __get__(self, instance: ICustomSectionValue, _):
+                return instance.getField(self.name)
+
+            def __set__(self, instance: ICustomSectionValue, value):
+                instance.setField(self.name, value)
+
+        def __init__(self, ref=None):
+            cast(Any, type(self).__bases__[0]).__init__(self, ref)
+
+        typeDict = {
+            "__init__": __init__,
+            "__module__": module,
+            "__doc__": f"This class represents the value of the LOGS custom field '{section.name}' (TypeID: {customTypeId} Index: {sectionIndex}  )",
+            "_name": section.name,
+            "_customTypeId": customTypeId,
+            "_sectionIndex": sectionIndex,
+            "_fieldNames": [],
+            "_fieldTypes": {},
+            "_fieldIds": {},
+            "_noSerialize": ["fieldNames"],
+        }
+
+        for f in customFields:
+            attrName = Tools.resolveKeyConflictWithPrefix(f.__name__, "_", typeDict)
+
+            typeDict["_" + attrName] = None
+            typeDict[attrName] = CustomFieldProperty(attrName)
+            typeDict["_fieldNames"].append(attrName)
+            typeDict["_fieldTypes"][attrName] = f
+            typeDict["_fieldIds"][f._id] = attrName
+
+        typeDict["_noSerialize"] += typeDict["_fieldNames"]
+
+        newClass: Type[ICustomSectionValue] = type(
+            name,
+            (ICustomSectionValue,),
+            typeDict,
+        )
+        return newClass

LOGS/Auxiliary/CustomTypeClassGenerator.py

@@ -0,0 +1,147 @@
+from base64 import b64encode
+from typing import TYPE_CHECKING, Any, Dict, Optional, Type, TypeVar, Union, cast
+
+from LOGS.Auxiliary.CheckClassName import CheckClassName
+from LOGS.Auxiliary.Constants import Constants
+from LOGS.Auxiliary.CustomSectionClassGenerator import CustomSectionClassGenerator
+from LOGS.Auxiliary.Exceptions import EntityFetchingException
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Interfaces.ICustomSectionValue import ICustomSectionValue
+from LOGS.Interfaces.ICustomTypeValue import ICustomTypeValue
+
+if TYPE_CHECKING:
+    from LOGS.Entities.CustomType import CustomType
+    from LOGS.LOGSConnection import LOGSConnection
+
+
+_T = TypeVar("_T")
+
+
+class CustomTypeClassGenerator:
+
+    _classCache: Dict[str, Type["ICustomTypeValue"]] = {}
+
+    @classmethod
+    def _getCacheKey(cls, customTypeOrId: int, connection: "LOGSConnection") -> str:
+        url = connection.getEndpointUrl(
+            ["custom_types", str(customTypeOrId)],
+        )
+        return b64encode(url.encode()).decode()
+
+    @classmethod
+    def generate(
+        cls,
+        customType: "CustomType",
+        connection: "LOGSConnection",
+        fieldName: Optional[str] = None,
+    ):
+
+        if not customType or not customType.id:
+            raise ValueError(f"Custom type is missing for field '{fieldName}'.")
+
+        cacheId = cls._getCacheKey(customType.id, connection)
+        if cacheId in cls._classCache:
+            return cls._classCache[cacheId]
+
+        sections = (
+            [
+                CustomSectionClassGenerator.generate(
+                    section,
+                    customTypeId=customType.id,
+                    sectionIndex=i,
+                    connection=connection,
+                )
+                for i, section in enumerate(customType.sections)
+            ]
+            if customType.sections
+            else []
+        )
+
+        name = (
+            CheckClassName.sanitizeClassName(customType.name)
+            if customType.name
+            else f"CustomType_ID{customType.id}"
+        )
+
+        module = ".".join(
+            ICustomTypeValue.__module__.split(".")[:-1] + ["GeneratedCustomTypeValues"],
+        )
+
+        class SectionProperty:
+            def __init__(self, name: str):
+                self.name = name
+
+            def __get__(self, instance: ICustomSectionValue, _):
+                return instance.getField(self.name)
+
+        def __init__(self, ref=None):
+            cast(Any, type(self).__bases__[0]).__init__(self, ref)
+
+        typeDict = {
+            "__init__": __init__,
+            "__module__": module,
+            "__doc__": f"This class represents the value of the LOGS custom type '{customType.name}' (TypeID: {customType.id})",
+            "_name": customType.name,
+            "_id": customType.id,
+            "_fieldNames": [],
+            "_fieldTypes": {},
+            "_fieldIds": {},
+            "_noSerialize": ["fieldNames"],
+        }
+
+        for s in sections:
+            attrName = Tools.resolveKeyConflictWithPrefix(s.__name__, "_", typeDict)
+
+            typeDict["_" + attrName] = None
+            typeDict[attrName] = SectionProperty(attrName)
+            typeDict["_fieldNames"].append(attrName)
+            typeDict["_fieldTypes"][attrName] = s
+            typeDict["_fieldIds"][s.getId()] = attrName
+
+        typeDict["_noSerialize"] += typeDict["_fieldNames"]
+
+        newClass: Type[ICustomTypeValue] = type(
+            name,
+            (ICustomTypeValue,),
+            typeDict,
+        )
+
+        return newClass
+
+    @classmethod
+    def convert(
+        cls,
+        value: Any,
+        customTypeOrId: Union["CustomType", int],
+        connection: "LOGSConnection",
+        fieldName: Optional[str] = None,
+    ) -> Optional["ICustomTypeValue"]:
+        from LOGS.Entities.CustomType import CustomType
+
+        if isinstance(value, ICustomTypeValue):
+            return value
+
+        if not isinstance(value, list):
+            raise ValueError(
+                f"Field '{fieldName}' cannot be converted from value of type '{type(value).__name__}'."
+            )
+
+        if isinstance(customTypeOrId, int):
+            customType = CustomType(id=customTypeOrId, connection=connection)
+            try:
+                customType.fetch()
+            except EntityFetchingException as e:
+                raise ValueError(
+                    f"Field '{fieldName}' cannot be converted:"
+                    + f"\n{Constants.exceptionIndentation}{str(e)}"
+                )
+        else:
+            customType = customTypeOrId
+
+        c = cls.generate(customType, connection, fieldName)
+        try:
+            return c(value)
+        except Exception as e:
+            raise ValueError(
+                f"Field '{fieldName}' cannot be converted to '{c.__name__}': {str(e)}"
+            ) from e

LOGS/Auxiliary/DateTimeConverter.py

@@ -0,0 +1,66 @@
+import datetime as dt
+import re
+import time
+from typing import List, cast
+
+import pytz
+
+
+class DateTimeConverter:
+    # When adding pattern here put the pattern with most information on top
+    _datePatterns = ["%Y-%m-%dT%H:%M:%S.%fZ", "%Y-%m-%dT%H:%M:%SZ", "%Y-%m-%d"]
+    _timePatterns = ["%H:%M:%S.%f", "%H:%M:%S", "%H:%M"]
+    utc_offset_re = re.compile(r"([\+-])(\d+)$")
+    multiSpace_re = re.compile(r"( {2,})")
+
+    @classmethod
+    def _getLocalTime(cls):
+        import platform
+
+        if platform.system() == "Windows":
+            from tzlocal.win32 import get_localzone_name
+
+            return pytz.timezone(get_localzone_name())
+        else:
+            return pytz.timezone(time.tzname[0])
+
+    @classmethod
+    def convertTime(cls, entry: str):
+        entry = re.sub(cls.multiSpace_re, " ", entry)
+        match = cls.utc_offset_re.search(entry)
+        if match and len(match.group(2)) == 3:
+            entry = entry.replace(match.group(0), match.group(1) + "0" + match.group(2))
+
+        times: List[dt.time] = []
+        for pattern in set(cast(List[str], cls._timePatterns)):
+            try:
+                times.append(dt.datetime.strptime(entry, pattern).time())
+            except:
+                continue
+        if len(times) < 1:
+            return None
+
+        return times[0]
+
+    @classmethod
+    def convertDateTime(cls, entry: str):
+        entry = re.sub(cls.multiSpace_re, " ", entry)
+        match = cls.utc_offset_re.search(entry)
+        if match and len(match.group(2)) == 3:
+            entry = entry.replace(match.group(0), match.group(1) + "0" + match.group(2))
+
+        dates: List[dt.datetime] = []
+        for pattern in set(cast(List[str], cls._datePatterns)):
+            try:
+                dates.append(dt.datetime.strptime(entry, pattern))
+            except:
+                continue
+        if len(dates) < 1:
+            return None
+
+        d = dates[0]
+        if d.tzinfo == pytz.UTC or d.tzinfo is None:
+            local_tz = cls._getLocalTime()
+            d = d.replace(tzinfo=pytz.utc).astimezone(local_tz)
+
+        return d

LOGS/Auxiliary/Decorators.py

@@ -0,0 +1,109 @@
+import types
+from typing import Any, Callable, List, Type, TypeVar, Union, cast
+
+TClass = TypeVar("TClass", bound=Callable[..., Any])
+
+
+class InitConstructor:
+    def _set_new_attribute(self, name, value):
+        # Never overwrites an existing attribute.  Returns True if the
+        # attribute already exists.
+        if name in self.__dict__:
+            return True
+        setattr(self, name, value)
+        return False
+
+    def _new_constructor(self):
+        print("New Constructor")
+
+    def __call__(self, classInput: TClass) -> TClass:
+        print(classInput.__class__)
+        c = cast(Type, classInput)
+
+        print(c.__init__.__code__.co_varnames)
+        print(c.__init__.__defaults__)
+        print(c.__init__.__code__)
+
+        constructor = types.FunctionType(self._new_constructor.__code__, {})
+
+        return classInput
+
+
+class Endpoint:
+    def __init__(self, path: Union[List[str], str]) -> None:
+        self.path = [path] if isinstance(path, str) else path
+
+    def __call__(self, classInput: TClass) -> TClass:
+        from LOGS.Entity.ConnectedEntity import ConnectedEntity
+        from LOGS.Entity.EntityConnector import EntityConnector
+
+        if not isinstance(classInput, type) or not issubclass(
+            classInput, (ConnectedEntity, EntityConnector)
+        ):
+            raise Exception(
+                "%s decorator expect %a or %a type. (got type %a)"
+                % (
+                    Endpoint.__name__,
+                    ConnectedEntity.__name__,
+                    EntityConnector.__name__,
+                    classInput.__name__,
+                )
+            )
+
+        classInput._endpoint = self.path
+
+        return cast(TClass, classInput)
+
+
+class UiEndpoint:
+    def __init__(self, path: Union[List[str], str]) -> None:
+        self.path = [path] if isinstance(path, str) else path
+
+    def __call__(self, classInput: TClass) -> TClass:
+        from LOGS.Entity.ConnectedEntity import ConnectedEntity
+
+        if not isinstance(classInput, type) or not issubclass(
+            classInput, (ConnectedEntity)
+        ):
+            raise Exception(
+                "%s decorator expect %a  type. (got type %a)"
+                % (Endpoint.__name__, ConnectedEntity.__name__, classInput.__name__)
+            )
+
+        classInput._uiEndpoint = self.path
+
+        return cast(TClass, classInput)
+
+
+class FullModel:
+    def __init__(self, fullEntity: Any) -> None:
+        self.fullEntity = fullEntity
+
+    def __call__(self, classInput: TClass) -> TClass:
+        if hasattr(classInput, "_fullEntityType"):
+            setattr(classInput, "_fullEntityType", self.fullEntity)
+        if hasattr(self.fullEntity, "_endpoint") and hasattr(classInput, "_endpoint"):
+            setattr(classInput, "_endpoint", getattr(self.fullEntity, "_endpoint"))
+
+        return classInput
+
+
+# --- Example for typed function decorator ---
+# TFun = TypeVar("TFun", bound=Callable[..., Any])
+
+# class FunctionDecorator:
+#     def __init__(self, path: Union[List[str], str]) -> None:
+#         self.path = [path] if isinstance(path, str) else path
+
+#     def __call__(self, func: TFun) -> TFun:
+#         path = self.path
+
+#         @wraps(func)
+#         def wrapper(*args, **kwargs) -> Any:
+#             # if isclass(classInput) and issubclass(classInput, ConnectedContent):
+#             #     cast(ConnectedContent, classInput)._endpoint = path
+#             if hasattr(func, "_endpoint"):
+#                 setattr(func, "_endpoint", path)
+#             return func(*args, **kwargs)
+
+#         return cast(TFun, wrapper)