logs-py 4.0.7__py3-none-any.whl

LOGS/Entity/EntityIterator.py

@@ -0,0 +1,263 @@
+import dataclasses
+from typing import Any, Generic, List, Optional, Type, TypeVar, cast
+
+from LOGS.Auxiliary.Constants import Constants
+from LOGS.Auxiliary.Exceptions import LOGSException
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Entity.Entity import Entity
+from LOGS.Entity.EntityConnector import EntityConnector
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Entity.IdIterator import EmptyIdIterator, IdIterator
+from LOGS.LOGSConnection import RESPONSE_TYPES, LOGSConnection, ResponseTypes
+
+# SELF = TypeVar("SELF", bound="EntityConnector")
+
+_ENTITY = TypeVar("_ENTITY", bound=Entity)
+_REQUEST = TypeVar("_REQUEST", bound=EntityRequestParameter)
+
+
+class EntityIterator(Generic[_ENTITY, _REQUEST], EntityConnector[_ENTITY]):
+    """Represents a connected LOGS entity iterator"""
+
+    _firstUrl: Optional[str] = None
+    _entityIterator: int
+    _currentResults: Optional[RESPONSE_TYPES]
+    _generatorType: Optional[Type[_ENTITY]] = None
+    _parameterType: Optional[Type[_REQUEST]] = None
+
+    _parameters: _REQUEST
+    _responseType: ResponseTypes = ResponseTypes.JSON
+    _includeUrl: bool = True
+    _connection: Optional[LOGSConnection]
+    _count: Optional[int]
+
+    def __init__(
+        self,
+        connection: Optional[LOGSConnection],
+        parameters: Optional[_REQUEST] = None,
+    ):
+        super().__init__(connection=connection)
+
+        if not self._parameterType:
+            raise NotImplementedError(
+                "Entity connection cannot be initialized without the request 'parameterType' field in class %a"
+                % type(self).__name__
+            )
+
+        if not isinstance(self._parameterType, type):
+            raise NotImplementedError(
+                "The field 'parameterType' must be a 'type' got %a in class %a"
+                % (type(self._parameterType), type(self).__name__)
+            )
+
+        if parameters and not isinstance(parameters, self._parameterType):
+            raise LOGSException(
+                "Parameter for iterator %a must be of type %a. (Got %a)"
+                % (
+                    type(self).__name__,
+                    self._parameterType.__name__,
+                    type(parameters).__name__,
+                )
+            )
+
+        self._parameters = Tools.checkAndConvert(
+            parameters, self._parameterType, "parameters", initOnNone=True
+        )
+
+        self._entityIterator = 0
+        self._currentResults = None
+        self._count = None
+
+    def __iter__(self):
+        self._initEntityIterator()
+        return self
+
+    def __next__(self) -> _ENTITY:
+        from LOGS.Auxiliary.CustomEntityClassGenerator import CustomEntityClassGenerator
+        from LOGS.Entity.ConnectedEntity import ConnectedEntity
+        from LOGS.Interfaces.ITypedEntity import ITypedEntity
+
+        if not self._generatorType:
+            raise NotImplementedError(
+                "Iterator cannot generate items without a specified 'generatorType' field in class %a"
+                % type(self).__name__
+            )
+
+        if issubclass(self._generatorType, ConnectedEntity):
+            next = cast(Any, self._generatorType)(
+                self._getNextEntity(), connection=self._connection
+            )
+        else:
+            next = cast(Any, self._generatorType)(self._getNextEntity())
+
+        if issubclass(self._generatorType, ITypedEntity):
+            next = CustomEntityClassGenerator.convertFromUntyped(
+                next, limitToEntityType=self._generatorType
+            )
+
+        return next
+
+    def _getNextPage(self, result):
+        if not self._connection:
+            raise LOGSException("Connection of %a is not defined" % type(self).__name__)
+
+        if "hasNext" not in result or not result["hasNext"]:
+            return None, None
+
+        url = result["url"]
+
+        page = 1
+        if "page" in result:
+            page = int(result["page"])
+        elif self._parameters.page:
+            page = self._parameters.page
+        self._parameters.page = page + 1
+        return self._connection.postUrl(
+            url=url,
+            data=self._parameters.toDict(),
+            responseType=self._responseType,
+            includeUrl=self._includeUrl,
+        )
+
+        # ### code for using get ###
+        # o = urlparse(result["url"])
+        # params = parse_qs(o.query)
+        # params = {k: v[0] if isinstance(v, list) else v for k, v in params.items()}
+
+        # page = 1
+        # if "page" in params:
+        #     page = int(params["page"])
+        # params["page"] = page + 1
+
+        # urlList = list(o)
+        # urlList[4] = None
+        # url = cast(str, urlunparse(urlList))
+
+        # return self._connection.getUrl(
+        #     url,
+        #     parameters=params,
+        #     responseType=self._responseType,
+        #     includeUrl=self._includeUrl,
+        # )
+
+    def _initEntityIterator(self):
+        url = self.getBaseUrl()
+        self._entityIterator = 0
+
+        if not self._connection:
+            raise LOGSException(
+                "Entity connector %a is not connected" % type(self).__name__
+            )
+
+        # ### code for using get ###
+        # self._currentResults, error = self._connection.getUrl(
+        #     url=url,
+        #     parameters=self._parameters.toDict(),
+        #     responseType=self._responseType,
+        #     includeUrl=self._includeUrl,
+        # )
+        tmp = False
+        if hasattr(self._parameters, "includeCount"):
+            tmp = self._parameters.includeCount
+            self._parameters.includeCount = True
+
+        self._currentResults, responseError = self._connection.postUrl(
+            url=url + "/list",
+            data=self._parameters.toDict(),
+            responseType=self._responseType,
+            includeUrl=self._includeUrl,
+        )
+
+        if hasattr(self._parameters, "includeCount"):
+            self._parameters.includeCount = tmp
+
+        if isinstance(self._currentResults, dict) and "count" in self._currentResults:
+            self._count = int(self._currentResults["count"])
+
+        if responseError:
+            raise LOGSException(responseError=responseError)
+
+    def _getNextEntity(self):
+        if not isinstance(self._currentResults, dict):
+            raise StopIteration
+
+        results = self._currentResults["results"]
+        if self._entityIterator < len(results):
+            result = results[self._entityIterator]
+            self._entityIterator += 1
+            return result
+
+        self._currentResults, error = self._getNextPage(self._currentResults)
+        if error:
+            raise Exception("Connection error: %a", error)
+        self._entityIterator = 0
+
+        if (
+            not self._currentResults
+            or not isinstance(self._currentResults, dict)
+            or len(self._currentResults["results"]) < 1
+        ):
+            raise StopIteration
+
+        return self._getNextEntity()
+
+    def split(self, size=20):
+        connection, _ = self._getConnectionData()
+
+        items = iter(self)
+        ids = []
+        for item in items:
+            ids.append(item.id)
+            if len(ids) >= size:
+                param = dataclasses.replace(self._parameters)
+                param.ids = ids
+                iterator = type(self)(connection=connection)
+                iterator._parameters = param
+                yield iterator
+                ids = []
+        if ids:
+            param = dataclasses.replace(self._parameters)
+            param.ids = ids
+            iterator = type(self)(connection=connection)
+            iterator._parameters = param
+            yield iterator
+
+    def ids(self):
+        if not self._generatorType:
+            return EmptyIdIterator[Constants.ID_TYPE]()
+        d = self._generatorType()
+        iterator = IdIterator[type(d.id), _REQUEST](connection=self._connection)
+        iterator._endpoint = self._endpoint
+        iterator._parameters = self._parameters
+        iterator._parameterType = self._parameterType
+        iterator._generatorType = type(d.id)
+        return iterator
+
+    def first(self):
+        i = iter(self)
+        try:
+            return cast(_ENTITY, next(i))
+        except StopIteration:
+            return None
+
+    def toList(self, count: Optional[int] = None):
+        if count:
+            count = int(count)
+            if count < 0:
+                raise Exception("Invalid negative count %d" % count)
+            result = cast(List[_ENTITY], [])
+            num = 0
+            for entity in self:
+                result.append(entity)
+                num += 1
+                if num >= count:
+                    break
+            return result
+
+        return list(self)
+
+    @property
+    def count(self) -> int:
+        if self._count is None:
+            self._initEntityIterator()
+        return self._count if self._count else 0

LOGS/Entity/EntityMinimal.py

@@ -0,0 +1,141 @@
+from typing import Generic, Optional, Type, TypeVar, cast
+from uuid import UUID
+
+from LOGS.Auxiliary.Exceptions import LOGSException
+from LOGS.Entity.ConnectedEntity import ConnectedEntity
+from LOGS.Entity.Entity import Entity
+from LOGS.LOGSConnection import LOGSConnection
+
+_FULL_ENTITY = TypeVar("_FULL_ENTITY", bound=Entity)
+_ID_TYPE = TypeVar("_ID_TYPE", int, str)
+
+
+class EntityMinimal(Generic[_ID_TYPE, _FULL_ENTITY], ConnectedEntity):
+    _id: Optional[_ID_TYPE]
+    _name: Optional[str]
+    _fullEntityType: Optional[Type[_FULL_ENTITY]] = None
+    _uid: Optional[UUID] = None
+    _version: Optional[int] = None
+    _isDeleted: Optional[bool] = None
+    _isLocked: Optional[bool] = None
+    _isSigned: Optional[bool] = None
+
+    def __init__(
+        self,
+        ref=None,
+        id: Optional[_ID_TYPE] = None,
+        connection: Optional[LOGSConnection] = None,
+        name: Optional[str] = None,
+    ):
+        """Represents a connected LOGS entity type"""
+        self._id = id
+        self._name = name
+        self._uid = None
+        self._version = None
+
+        if isinstance(ref, Entity):
+            self._id = cast(_ID_TYPE, ref.id)
+            if hasattr(ref, "name"):
+                self._name = getattr(ref, "name")
+            ref = None
+        super().__init__(ref=ref, connection=connection)
+
+    def contentToString(self, indentation: int = 1, hideNone: bool = False) -> str:
+        return str(self)
+
+    def __str__(self):
+        s = " name:'%s'" % (self.name if self.name else "")
+        return "<%s id:%s%s>" % (type(self).__name__, str(self.id), s)
+
+    def _fetchEntity(self, connection: LOGSConnection):
+        from LOGS.Interfaces.ITypedEntity import ITypedEntity
+
+        if not self._endpoint:
+            raise NotImplementedError(
+                "Fetching of entity type %a is not implemented."
+                % (
+                    type(self).__name__
+                    if type(self).__name__ != EntityMinimal.__name__
+                    else "unknown"
+                )
+            )
+
+        if not self._fullEntityType:
+            raise LOGSException("Full entity type of %a not set." % type(self).__name__)
+
+        entity = cast(Type[_FULL_ENTITY], self._fullEntityType)(
+            id=self.id, connection=connection
+        )
+        entity.fetch()
+        if isinstance(entity, ITypedEntity):
+            entity = entity._getTypedInstance()
+
+        return entity
+
+    def fetchFullEntity(self):
+        return self._fetchEntity(self._getConnection())
+
+    @property
+    def identifier(self):
+        name = self.name
+        return "%s(id:%s) %s" % (
+            type(self).__name__,
+            str(self.id),
+            "'" + name + "'" if name else "",
+        )
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        self._name = self.checkAndConvert(value, str, "name", allowNone=True)
+
+    @property
+    def id(self):
+        return self._id
+
+    @id.setter
+    def id(self, value):
+        self._id = value
+
+    @property
+    def uid(self) -> Optional[UUID]:
+        return self._uid
+
+    @uid.setter
+    def uid(self, value):
+        self._uid = self.checkAndConvert(value, UUID, "uid", allowNone=True)
+
+    @property
+    def version(self) -> Optional[int]:
+        return self._version
+
+    @version.setter
+    def version(self, value):
+        self._version = self.checkAndConvert(value, int, "uid", allowNone=True)
+
+    @property
+    def isDeleted(self) -> Optional[bool]:
+        return self._isDeleted
+
+    @isDeleted.setter
+    def isDeleted(self, value):
+        self._isDeleted = self.checkAndConvert(value, bool, "isDeleted", allowNone=True)
+
+    @property
+    def isLocked(self) -> Optional[bool]:
+        return self._isLocked
+
+    @isLocked.setter
+    def isLocked(self, value):
+        self._isLocked = self.checkAndConvert(value, bool, "isLocked", allowNone=True)
+
+    @property
+    def isSigned(self) -> Optional[bool]:
+        return self._isSigned
+
+    @isSigned.setter
+    def isSigned(self, value):
+        self._isSigned = self.checkAndConvert(value, bool, "isSigned", allowNone=True)

LOGS/Entity/EntityMinimalWithIntId.py

@@ -0,0 +1,36 @@
+from typing import TYPE_CHECKING, Generic, Optional, TypeVar
+
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Entity.EntityMinimal import EntityMinimal
+from LOGS.LOGSConnection import LOGSConnection
+
+if TYPE_CHECKING:
+    from LOGS.Entity.Entity import Entity
+
+_FULL_ENTITY = TypeVar("_FULL_ENTITY", bound="Entity")
+
+
+class EntityMinimalWithIntId(Generic[_FULL_ENTITY], EntityMinimal[int, _FULL_ENTITY]):
+    _id: int
+
+    def __init__(
+        self,
+        ref=None,
+        id: Optional[int] = 0,
+        connection: Optional[LOGSConnection] = None,
+        name: Optional[str] = None,
+    ):
+        """Represents a connected LOGS entity type"""
+        super().__init__(ref=ref, id=id, name=name, connection=connection)
+
+    def __str__(self):
+        s = " name:'%s'" % (self.name if self.name else "")
+        return "<%s id:%s%s>" % (type(self).__name__, str(self.id), s)
+
+    @property
+    def id(self) -> int:
+        return self._id
+
+    @id.setter
+    def id(self, value):
+        self._id = Tools.checkAndConvert(value, int, "id")

LOGS/Entity/EntityMinimalWithStrId.py

@@ -0,0 +1,36 @@
+from typing import TYPE_CHECKING, Generic, Optional, TypeVar
+
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Entity.EntityMinimal import EntityMinimal
+from LOGS.LOGSConnection import LOGSConnection
+
+if TYPE_CHECKING:
+    from LOGS.Entity.Entity import Entity
+
+_FULL_ENTITY = TypeVar("_FULL_ENTITY", bound="Entity")
+
+
+class EntityMinimalWithStrId(Generic[_FULL_ENTITY], EntityMinimal[str, _FULL_ENTITY]):
+    _id: str
+
+    def __init__(
+        self,
+        ref=None,
+        id: Optional[str] = "",
+        connection: Optional[LOGSConnection] = None,
+        name: Optional[str] = None,
+    ):
+        """Represents a connected LOGS entity type"""
+        super().__init__(ref=ref, id=id, name=name, connection=connection)
+
+    def __str__(self):
+        s = " name:'%s'" % (self.name if self.name else "")
+        return "<%s id:%s%s>" % (type(self).__name__, str(self.id), s)
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @id.setter
+    def id(self, value):
+        self._id = Tools.checkAndConvert(value, str, "id")

LOGS/Entity/EntityMinimalWithType.py

@@ -0,0 +1,47 @@
+from typing import Optional
+
+from LOGS.Auxiliary.Constants import Constants
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Entity.EntityMinimal import EntityMinimal
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.LOGSConnection import LOGSConnection
+
+
+class EntityMinimalWithType(EntityMinimal):
+    _id: int
+    _type: str
+    _defaultRequestParameter: dict = EntityRequestParameter().toDict()
+
+    def __init__(
+        self,
+        ref=None,
+        id: Optional[Constants.ID_TYPE] = None,
+        connection: Optional[LOGSConnection] = None,
+        name: Optional[str] = None,
+        type: str = "",
+    ):
+        """Represents a connected LOGS entity type"""
+
+        self._type = type
+        super().__init__(ref=ref, id=id, name=name, connection=connection)
+
+    def __str__(self):
+        n = " name:'%s'" % (self.name if self.name else "")
+        t = " type:'%s'" % (self.type if self.type else "")
+        return "<%s id:%s%s%s>" % (type(self).__name__, str(self.id), n, t)
+
+    @property
+    def id(self) -> int:
+        return self._id
+
+    @id.setter
+    def id(self, value):
+        self._id = Tools.checkAndConvert(value, int, "id")
+
+    @property
+    def type(self) -> str:
+        return self._type
+
+    @type.setter
+    def type(self, value):
+        self._type = Tools.checkAndConvert(value, str, "type")

LOGS/Entity/EntityRequestParameter.py

@@ -0,0 +1,104 @@
+from dataclasses import dataclass, field
+from typing import (
+    Any,
+    Callable,
+    Generic,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from LOGS.Entity.EntitySortBy import EntitySortBy, SortDirection
+from LOGS.Entity.IGenericEntityOrderBy import (
+    IBaseEntityOrderBy,
+    IGenericEntitySortingOptions,
+    INamedEntitySortingOptions,
+)
+from LOGS.Entity.SerializableContent import SerializableClass
+from LOGS.Interfaces.IPaginationRequest import IPaginationRequest
+
+
+class DefaultSortingOptions(IGenericEntitySortingOptions, INamedEntitySortingOptions):
+    pass
+
+
+_Sorting = TypeVar("_Sorting", bound=IBaseEntityOrderBy)
+
+
+@dataclass
+class EntityRequestParameter(Generic[_Sorting], SerializableClass, IPaginationRequest):
+    _orderByType: Type[_Sorting] = field(default=cast(Type[_Sorting], None), init=False)
+
+    _getOrderbyType: Callable[[], Type[_Sorting]] = field(
+        default=lambda: cast(Type[_Sorting], None), init=False
+    )
+
+    excludeIds: Optional[Union[List[int], List[str]]] = None
+    searchTerm: Optional[str] = None
+    ids: Optional[Union[List[int], List[str]]] = None
+    includeCount: Optional[bool] = None
+    sortBy: Optional[
+        Union[
+            List[
+                Union[
+                    Tuple[_Sorting, SortDirection],
+                    Tuple[int, SortDirection],
+                    _Sorting,
+                    int,
+                ]
+            ],
+            _Sorting,
+            int,
+        ]
+    ] = None
+
+    def __post_init__(self):
+        orderByType = self.__class__._orderByType
+        if type(self) is not EntityRequestParameter and not orderByType:
+            raise NotImplementedError(
+                f"{self.__class__.__name__} does not define an order type."
+            )
+
+        if self.sortBy:
+            if not isinstance(self.sortBy, list):
+                self.sortBy = [self.sortBy]
+
+            convertedSortBy: List[EntitySortBy[_Sorting]] = []
+            for i, t in enumerate(self.sortBy):
+                if not isinstance(t, tuple):
+                    t = (t, SortDirection.ASC)
+
+                if isinstance(t[0], int):
+                    customFieldId = t[0]
+                    property = orderByType.CUSTOM_FIELD
+                elif isinstance(t[0], (orderByType, str)):
+                    customFieldId = None
+                    property = self.checkAndConvert(
+                        t[0], orderByType, f"sortBy[{i}][0]"
+                    )
+                else:
+                    raise TypeError(
+                        f"Invalid type '{type(t[0]).__name__}' for sortBy[{i}][0]. (Expected int or {orderByType.__name__})"
+                    )
+
+                if len(t) > 1:
+                    direction = self.checkAndConvert(
+                        t[1], SortDirection, f"sortBy[{i}][1]"
+                    )
+                else:
+                    direction = SortDirection.ASC
+
+                convertedSortBy.append(
+                    EntitySortBy[_Sorting](
+                        orderByType=orderByType,
+                        property=property,
+                        sortDirection=direction,
+                        customFieldId=customFieldId,
+                    )
+                )
+
+            self.sortBy = cast(Any, convertedSortBy)

LOGS/Entity/EntitySortBy.py

@@ -0,0 +1,69 @@
+from enum import Enum
+from typing import Generic, Optional, Type, TypeVar, cast
+
+from LOGS.Entity.IGenericEntityOrderBy import IBaseEntityOrderBy
+from LOGS.Entity.SerializableContent import SerializableContent
+
+_ORDER = TypeVar("_ORDER", bound=IBaseEntityOrderBy)
+
+
+class SortDirection(Enum):
+    ASC = "ASC"
+    DESC = "DESC"
+
+
+_builtInProperty = property  # this avoids a name conflict between the @property decorator and field property
+
+
+class EntitySortBy(Generic[_ORDER], SerializableContent):
+    _orderByType: Type[_ORDER] = cast(Type[_ORDER], None)
+
+    _property: Optional[_ORDER] = None
+    _sortDirection: SortDirection = SortDirection.ASC
+    _customFieldId: Optional[int] = None
+
+    def __init__(
+        self,
+        orderByType: Type[_ORDER],
+        property: _ORDER,
+        sortDirection: SortDirection = SortDirection.ASC,
+        customFieldId: Optional[int] = None,
+    ):
+        super().__init__()
+
+        self._orderByType = orderByType
+        if not self._orderByType:
+            raise NotImplementedError(
+                f"{self.__class__.__name__} does not define an order type."
+            )
+
+        self.property = property
+        self.sortDirection = sortDirection
+        self.customFieldId = customFieldId
+
+    @_builtInProperty
+    def property(self) -> Optional[_ORDER]:
+        return self._property
+
+    @property.setter
+    def property(self, value):
+
+        self._property = self.checkAndConvert(value, self._orderByType, "property")
+
+    @_builtInProperty
+    def sortDirection(self) -> SortDirection:
+        return self._sortDirection
+
+    @sortDirection.setter
+    def sortDirection(self, value: SortDirection):
+        self._sortDirection = self.checkAndConvert(
+            value, SortDirection, "sortDirection"
+        )
+
+    @_builtInProperty
+    def customFieldId(self) -> Optional[int]:
+        return self._customFieldId
+
+    @customFieldId.setter
+    def customFieldId(self, value: Optional[int]):
+        self._customFieldId = self.checkAndConvertNullable(value, int, "customFieldId")