logs-py 4.0.7__py3-none-any.whl

LOGS/Entities/AttachmentRequestParameter.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Type
+
+from LOGS.Entities.DatasetRequestParameter import ParsingStates
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Entity.IGenericEntityOrderBy import (
+    IEntryRecordSortingOptions,
+    IGenericEntitySortingOptions,
+    IModificationRecordSortingOptions,
+)
+from LOGS.Interfaces.IEntryRecord import IEntryRecordRequest
+from LOGS.Interfaces.IModificationRecord import IModificationRecordRequest
+from LOGS.Interfaces.INamedEntity import INamedEntityRequest
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntityRequest
+
+
+class AttachmentSortingOptions(
+    IGenericEntitySortingOptions,
+    IEntryRecordSortingOptions,
+    IModificationRecordSortingOptions,
+):
+    pass
+
+
+@dataclass
+class AttachmentRequestParameter(
+    EntityRequestParameter[AttachmentSortingOptions],
+    IUniqueEntityRequest,
+    INamedEntityRequest,
+    IEntryRecordRequest,
+    IModificationRecordRequest,
+):
+    _orderByType: Type[AttachmentSortingOptions] = field(
+        default=AttachmentSortingOptions, init=False
+    )
+
+    parsingState: Optional[List[ParsingStates]] = None
+    pathContains: Optional[str] = None
+
+    # Additional fetch options
+    includeInfo: Optional[bool] = None
+    includeZipSize: Optional[bool] = None

LOGS/Entities/Attachments.py

@@ -0,0 +1,53 @@
+import dataclasses
+from typing import List, Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.Attachment import Attachment
+from LOGS.Entities.AttachmentRequestParameter import AttachmentRequestParameter
+from LOGS.Entities.DatasetModels import ViewableEntityTypes
+from LOGS.Entity.EntityIterator import EntityIterator
+from LOGS.LOGSConnection import LOGSConnection
+
+
+class _AttachmentRequestParameter(AttachmentRequestParameter):
+    isViewableEntity: bool = True
+    viewableEntityTypes: List[ViewableEntityTypes] = [ViewableEntityTypes.CustomField]
+
+    def __init__(self, ref: Optional[AttachmentRequestParameter] = None):
+        if ref is None:
+            super().__init__()
+            return
+        fieldValues = {f.name: getattr(ref, f.name) for f in dataclasses.fields(ref)}
+        super().__init__(**fieldValues)
+
+
+@Endpoint("datasets")
+class Attachments(EntityIterator[Attachment, AttachmentRequestParameter]):
+    """LOGS connected class Attachments iterator"""
+
+    _generatorType = Attachment
+    _parameterType = AttachmentRequestParameter
+
+    def __init__(
+        self,
+        connection: Optional[LOGSConnection],
+        parameters: Optional[AttachmentRequestParameter] = None,
+    ):
+        self._parameterType = _AttachmentRequestParameter
+        parameters = (
+            _AttachmentRequestParameter(parameters)
+            if parameters
+            else _AttachmentRequestParameter()
+        )
+
+        super().__init__(connection=connection, parameters=parameters)
+
+    def __next__(self):
+        attachment = super().__next__()
+
+        if self._parameters.includeInfo:
+            attachment.fetchInfo()
+        if self._parameters.includeZipSize:
+            attachment.fetchZipSize()
+
+        return attachment

LOGS/Entities/AutoloadFileInfo.py

@@ -0,0 +1,12 @@
+from datetime import datetime
+from typing import Optional
+
+from LOGS.Entity.SerializableContent import SerializableClass
+
+
+class AutoloadFileInfo(SerializableClass):
+    name: Optional[str] = None
+    fullPath: Optional[str] = None
+    size: Optional[int] = None
+    modTime: Optional[datetime] = None
+    isDir: Optional[bool] = None

LOGS/Entities/AutoloadStatusError.py

@@ -0,0 +1,7 @@
+from typing import Optional
+
+from LOGS.Entity.SerializableContent import SerializableClass
+
+
+class AutoloadStatusError(SerializableClass):
+    message: Optional[str] = None

LOGS/Entities/AxisNaming.py

@@ -0,0 +1,33 @@
+from typing import Optional
+
+from LOGS.Entity.SerializableContent import SerializableContent
+
+
+class AxisNaming(SerializableContent):
+    _x: Optional[str] = None
+    _y: Optional[str] = None
+    _z: Optional[str] = None
+
+    @property
+    def x(self) -> Optional[str]:
+        return self._x
+
+    @x.setter
+    def x(self, value):
+        self._x = self.checkAndConvertNullable(value, str, "x")
+
+    @property
+    def y(self) -> Optional[str]:
+        return self._y
+
+    @y.setter
+    def y(self, value):
+        self._y = self.checkAndConvertNullable(value, str, "y")
+
+    @property
+    def z(self) -> Optional[str]:
+        return self._z
+
+    @z.setter
+    def z(self, value):
+        self._z = self.checkAndConvertNullable(value, str, "z")

LOGS/Entities/AxisZoom.py

@@ -0,0 +1,33 @@
+from typing import List, Optional
+
+from LOGS.Entity.SerializableContent import SerializableContent
+
+
+class AxisZoom(SerializableContent):
+    _x: Optional[List[float]] = None
+    _y: Optional[List[float]] = None
+    _z: Optional[List[float]] = None
+
+    @property
+    def x(self) -> Optional[List[float]]:
+        return self._x
+
+    @x.setter
+    def x(self, value):
+        self._x = self.checkListAndConvertNullable(value, float, "x")
+
+    @property
+    def y(self) -> Optional[List[float]]:
+        return self._y
+
+    @y.setter
+    def y(self, value):
+        self._y = self.checkListAndConvertNullable(value, float, "y")
+
+    @property
+    def z(self) -> Optional[List[float]]:
+        return self._z
+
+    @z.setter
+    def z(self, value):
+        self._z = self.checkListAndConvertNullable(value, float, "z")

LOGS/Entities/Bridge.py

@@ -0,0 +1,165 @@
+from enum import Enum
+from typing import List, Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Auxiliary.Exceptions import LOGSMultilineException
+from LOGS.Entities.AutoloadFileInfo import AutoloadFileInfo
+from LOGS.Entities.BridgeClientInfo import BridgeClientInfo
+from LOGS.Entities.BridgeType import BridgeType
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
+from LOGS.Interfaces.IEntryRecord import IEntryRecord
+from LOGS.Interfaces.IModificationRecord import IModificationRecord
+from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.Interfaces.IPermissionedEntity import IGenericPermissionEntity
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
+
+
+class SFTPAuthenticationMethodOption(Enum):
+    PrivateKey = "PrivateKey"
+    Password = "Password"
+
+
+@Endpoint("bridges")
+class Bridge(
+    IEntityWithIntId,
+    IUniqueEntity,
+    INamedEntity,
+    IEntryRecord,
+    IModificationRecord,
+    IGenericPermissionEntity,
+):
+    _type: Optional[BridgeType] = None
+    _hostname: Optional[str] = None
+    _ipAddress: Optional[str] = None
+    _description: Optional[str] = None
+    _username: Optional[str] = None
+    _port: Optional[int] = None
+    _connectedClients: Optional[List[BridgeClientInfo]] = None
+    _isConnected: Optional[bool] = None
+    _areMultipleClientsConnected: Optional[bool] = None
+    _sftpAuthenticationMethod: Optional[SFTPAuthenticationMethodOption] = None
+
+    _password: Optional[str] = None
+    _privateKey: Optional[str] = None
+
+    def readDirectory(self):
+        connection, endpoint, id = self._getConnectionData()
+
+        data, responseError = connection.postEndpoint(endpoint + [id, "read_directory"])
+        if responseError:
+            raise LOGSMultilineException(responseError=responseError)
+
+        return self.checkListAndConvertNullable(
+            data, AutoloadFileInfo, "directory content"
+        )
+
+    @property
+    def url(self):
+        return "{type}://{user}@{host}{port}".format(
+            type=str(self.type.name if self.type else "").lower(),
+            user=self.username,
+            host=self.hostname,
+            port=":%d" % self.port if self.port else ":22",
+        )
+
+    @property
+    def type(self) -> Optional[BridgeType]:
+        return self._type
+
+    @type.setter
+    def type(self, value):
+        self._type = self.checkAndConvertNullable(value, BridgeType, "type")
+
+    @property
+    def hostname(self) -> Optional[str]:
+        return self._hostname
+
+    @hostname.setter
+    def hostname(self, value):
+        self._hostname = self.checkAndConvertNullable(value, str, "hostname")
+
+    @property
+    def ipAddress(self) -> Optional[str]:
+        return self._ipAddress
+
+    @ipAddress.setter
+    def ipAddress(self, value):
+        self._ipAddress = self.checkAndConvertNullable(value, str, "ipAddress")
+
+    @property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @description.setter
+    def description(self, value):
+        self._description = self.checkAndConvertNullable(value, str, "description")
+
+    @property
+    def username(self) -> Optional[str]:
+        return self._username
+
+    @username.setter
+    def username(self, value):
+        self._username = self.checkAndConvertNullable(value, str, "username")
+
+    @property
+    def port(self) -> Optional[int]:
+        return self._port
+
+    @port.setter
+    def port(self, value):
+        self._port = self.checkAndConvertNullable(value, int, "port")
+
+    @property
+    def connectedClients(self) -> Optional[List[BridgeClientInfo]]:
+        return self._connectedClients
+
+    @connectedClients.setter
+    def connectedClients(self, value):
+        self._connectedClients = self.checkListAndConvertNullable(
+            value, BridgeClientInfo, "connectedClients"
+        )
+
+    @property
+    def isConnected(self) -> Optional[bool]:
+        return self._isConnected
+
+    @isConnected.setter
+    def isConnected(self, value):
+        self._isConnected = self.checkAndConvertNullable(value, bool, "isConnected")
+
+    @property
+    def areMultipleClientsConnected(self) -> Optional[bool]:
+        return self._areMultipleClientsConnected
+
+    @areMultipleClientsConnected.setter
+    def areMultipleClientsConnected(self, value):
+        self._areMultipleClientsConnected = self.checkAndConvertNullable(
+            value, bool, "areMultipleClientsConnected"
+        )
+
+    @property
+    def sftpAuthenticationMethod(self) -> Optional[SFTPAuthenticationMethodOption]:
+        return self._sftpAuthenticationMethod
+
+    @sftpAuthenticationMethod.setter
+    def sftpAuthenticationMethod(self, value):
+        self._sftpAuthenticationMethod = self.checkAndConvertNullable(
+            value, SFTPAuthenticationMethodOption, "sftpAuthenticationMethod"
+        )
+
+    @property
+    def password(self) -> Optional[str]:
+        return self._password
+
+    @password.setter
+    def password(self, value):
+        self._password = self.checkAndConvertNullable(value, str, "password")
+
+    @property
+    def privateKey(self) -> Optional[str]:
+        return self._privateKey
+
+    @privateKey.setter
+    def privateKey(self, value):
+        self._privateKey = self.checkAndConvertNullable(value, str, "privateKey")

LOGS/Entities/BridgeClientInfo.py

@@ -0,0 +1,93 @@
+from datetime import datetime
+from typing import Optional
+from uuid import UUID
+
+from LOGS.Entity.SerializableContent import SerializableContent
+
+
+class BridgeClientInfo(SerializableContent):
+    _id: Optional[UUID] = None
+    _host: Optional[str] = None
+    _clientVersion: Optional[str] = None
+    _ipAddress: Optional[str] = None
+    _executablePath: Optional[str] = None
+    _operatingSystem: Optional[str] = None
+    _firstSeen: Optional[datetime] = None
+    _isApproved: Optional[bool] = None
+    _bridgeId: Optional[int] = None
+
+    @property
+    def id(self) -> Optional[UUID]:
+        return self._id
+
+    @id.setter
+    def id(self, value):
+        self._id = self.checkAndConvertNullable(value, UUID, "id")
+
+    @property
+    def host(self) -> Optional[str]:
+        return self._host
+
+    @host.setter
+    def host(self, value):
+        self._host = self.checkAndConvertNullable(value, str, "host")
+
+    @property
+    def clientVersion(self) -> Optional[str]:
+        return self._clientVersion
+
+    @clientVersion.setter
+    def clientVersion(self, value):
+        self._clientVersion = self.checkAndConvertNullable(value, str, "clientVersion")
+
+    @property
+    def ipAddress(self) -> Optional[str]:
+        return self._ipAddress
+
+    @ipAddress.setter
+    def ipAddress(self, value):
+        self._ipAddress = self.checkAndConvertNullable(value, str, "ipAddress")
+
+    @property
+    def executablePath(self) -> Optional[str]:
+        return self._executablePath
+
+    @executablePath.setter
+    def executablePath(self, value):
+        self._executablePath = self.checkAndConvertNullable(
+            value, str, "executablePath"
+        )
+
+    @property
+    def operatingSystem(self) -> Optional[str]:
+        return self._operatingSystem
+
+    @operatingSystem.setter
+    def operatingSystem(self, value):
+        self._operatingSystem = self.checkAndConvertNullable(
+            value, str, "operatingSystem"
+        )
+
+    @property
+    def firstSeen(self) -> Optional[datetime]:
+        return self._firstSeen
+
+    @firstSeen.setter
+    def firstSeen(self, value):
+        self._firstSeen = self.checkAndConvertNullable(value, datetime, "firstSeen")
+
+    @property
+    def isApproved(self) -> Optional[bool]:
+        return self._isApproved
+
+    @isApproved.setter
+    def isApproved(self, value):
+        self._isApproved = self.checkAndConvertNullable(value, bool, "isApproved")
+
+    @property
+    def bridgeId(self) -> Optional[int]:
+        return self._bridgeId
+
+    @bridgeId.setter
+    def bridgeId(self, value):
+        self._bridgeId = self.checkAndConvertNullable(value, int, "bridgeId")

LOGS/Entities/BridgeMinimal.py

@@ -0,0 +1,8 @@
+from LOGS.Auxiliary.Decorators import FullModel
+from LOGS.Entities.Bridge import Bridge
+from LOGS.Entity.EntityMinimalWithIntId import EntityMinimalWithIntId
+
+
+@FullModel(Bridge)
+class BridgeMinimal(EntityMinimalWithIntId[Bridge]):
+    pass

LOGS/Entities/BridgeRequestParameter.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Type, cast
+
+from typing_extensions import Self
+
+from LOGS.Entities.BridgeType import BridgeType
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Entity.IGenericEntityOrderBy import (
+    IEntryRecordSortingOptions,
+    IGenericEntitySortingOptions,
+    IModificationRecordSortingOptions,
+    INamedEntitySortingOptions,
+)
+from LOGS.Interfaces.IEntryRecord import IEntryRecordRequest
+from LOGS.Interfaces.IModificationRecord import IModificationRecordRequest
+from LOGS.Interfaces.INamedEntity import INamedEntityRequest
+from LOGS.Interfaces.IPermissionedEntity import IPermissionedEntityRequest
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntityRequest
+
+
+class BridgeSortingOptions(
+    IGenericEntitySortingOptions,
+    INamedEntitySortingOptions,
+    IEntryRecordSortingOptions,
+    IModificationRecordSortingOptions,
+):
+    TYPE: Self = cast(Self, "TYPE")
+
+
+@dataclass
+class BridgeRequestParameter(
+    EntityRequestParameter[BridgeSortingOptions],
+    INamedEntityRequest,
+    IUniqueEntityRequest,
+    IEntryRecordRequest,
+    IModificationRecordRequest,
+    IPermissionedEntityRequest,
+):
+    _orderByType: Type[BridgeSortingOptions] = field(
+        default=BridgeSortingOptions, init=False
+    )
+
+    hostnames: Optional[List[str]] = None
+    usernames: Optional[List[str]] = None
+    ipAddresses: Optional[List[str]] = None
+    dataSourceIds: Optional[List[int]] = None
+    types: Optional[List[BridgeType]] = None
+    datasetIds: Optional[List[int]] = None
+    isConfigured: Optional[bool] = None

LOGS/Entities/BridgeType.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class BridgeType(Enum):
+    Unknown = "Unknown"
+    Client = "Client"
+    SFTP = "SFTP"

LOGS/Entities/Bridges.py

@@ -0,0 +1,12 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.Bridge import Bridge
+from LOGS.Entities.BridgeRequestParameter import BridgeRequestParameter
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("bridges")
+class Bridges(EntityIterator[Bridge, BridgeRequestParameter]):
+    """LOGS connected class Bridges iterator"""
+
+    _generatorType = Bridge
+    _parameterType = BridgeRequestParameter