rucio-clients 35.7.0__py3-none-any.whl → 37.0.0rc2__py3-none-any.whl

rucio/common/types.py

@@ -14,40 +14,39 @@
 
 import sys
 from collections.abc import Callable
-from datetime import datetime
 from os import PathLike
 
-if sys.version_info < (3, 11):
-    from typing_extensions import TYPE_CHECKING, Any, Literal, NotRequired, Optional, TypedDict, Union  # noqa: UP035
+if sys.version_info < (3, 11):  # pragma: no cover
+    from typing_extensions import TYPE_CHECKING, Any, Literal, NotRequired, Optional, TypedDict, TypeGuard, Union  # noqa: UP035
     PathTypeAlias = Union[PathLike, str]
 else:
-    from typing import TYPE_CHECKING, Any, Literal, NotRequired, Optional, TypedDict, Union
+    from typing import TYPE_CHECKING, Any, Literal, NotRequired, Optional, TypedDict, TypeGuard, Union
     PathTypeAlias = PathLike
 
 
 if TYPE_CHECKING:
+    from datetime import datetime
+
     from rucio.common.constants import SUPPORTED_PROTOCOLS_LITERAL
-    from rucio.db.sqla.constants import AccountType, IdentityType, RequestState, RequestType
+    from rucio.db.sqla.constants import AccountType, IdentityType, ReplicaState, RequestState, RequestType, RSEType
 
 
 class InternalType:
     '''
     Base for Internal representations of string types
     '''
-    def __init__(self, value: Optional[str], vo: str = 'def', fromExternal: bool = True):
+    def __init__(self, value: Optional[str], vo: str = 'def', from_external: bool = True):
         if value is None:
             self.external = None
             self.internal = None
             self.vo = vo
-        elif not isinstance(value, str):
-            raise TypeError('Expected value to be string type, got %s' % type(value))
-        elif fromExternal:
+        elif from_external:
             self.external = value
             self.vo = vo
-            self.internal = self._calc_internal()
+            self.internal = _RepresentationCalculator.calc_internal(self.external, self.vo)
         else:
             self.internal = value
-            vo, external = self._calc_external()
+            vo, external = _RepresentationCalculator.calc_external(self.internal)
             self.external = external
             self.vo = vo
 
@@ -58,49 +57,56 @@ class InternalType:
         return self.external
 
     def __eq__(self, other):
-        if isinstance(other, self.__class__):
+        if type(self) is type(other):
             return self.internal == other.internal
         return NotImplemented
 
-    def __ne__(self, other):
-        val = self == other
-        if val is NotImplemented:
-            return NotImplemented
-        return not val
-
     def __le__(self, other):
-        val = self.external <= other.external
-        if val is NotImplemented:
-            return NotImplemented
-        return val
+        if type(self) is type(other) and self.external is not None and other.external is not None:
+            return self.external <= other.external
+        return NotImplemented
 
     def __lt__(self, other):
-        val = self.external < other.external
-        if val is NotImplemented:
-            return NotImplemented
-        return val
+        if type(self) is type(other) and self.external is not None and other.external is not None:
+            return self.external < other.external
+        return NotImplemented
 
     def __hash__(self):
         return hash(self.internal)
 
-    def _calc_external(self) -> tuple[str, str]:
-        ''' Utility to convert between internal and external representations'''
-        if isinstance(self.internal, str):
-            split = self.internal.split('@', 1)
-            if len(split) == 1:  # if cannot convert, vo is '' and this is single vo
-                vo = 'def'
-                external = split[0]
-            else:
-                vo = split[1]
-                external = split[0]
-            return vo, external
-        return '', ''
-
-    def _calc_internal(self) -> str:
-        ''' Utility to convert between internal and external representations'''
-        if self.vo == 'def' and self.external is not None:
-            return self.external
-        internal = '{}@{}'.format(self.external, self.vo)
+
+class _RepresentationCalculator:
+    @staticmethod
+    def calc_external(internal: str) -> tuple[str, str]:
+        """
+        Calculate external representation from internal representation
+
+        :param internal: internal representation
+
+        :returns: tuple of VO and external representation
+        """
+        split = internal.split('@', 1)
+        if len(split) == 1:  # if cannot convert, vo is '' and this is single vo
+            vo = 'def'
+            external = split[0]
+        else:
+            vo = split[1]
+            external = split[0]
+        return vo, external
+
+    @staticmethod
+    def calc_internal(external: str, vo: str) -> str:
+        """
+        Calculate internal representation from external representation and VO
+
+        :param external: external representation
+        :param vo: VO name
+
+        :returns: internal representation
+        """
+        if vo == 'def':
+            return external
+        internal = '{}@{}'.format(external, vo)
         return internal
 
 
@@ -108,16 +114,16 @@ class InternalAccount(InternalType):
     '''
     Internal representation of an account
     '''
-    def __init__(self, account: Optional[str], vo: str = 'def', fromExternal: bool = True):
-        super(InternalAccount, self).__init__(value=account, vo=vo, fromExternal=fromExternal)
+    def __init__(self, account: Optional[str], vo: str = 'def', from_external: bool = True):
+        super(InternalAccount, self).__init__(value=account, vo=vo, from_external=from_external)
 
 
 class InternalScope(InternalType):
     '''
     Internal representation of a scope
     '''
-    def __init__(self, scope: Optional[str], vo: str = 'def', fromExternal: bool = True):
-        super(InternalScope, self).__init__(value=scope, vo=vo, fromExternal=fromExternal)
+    def __init__(self, scope: Optional[str], vo: str = 'def', from_external: bool = True):
+        super(InternalScope, self).__init__(value=scope, vo=vo, from_external=from_external)
 
 
 LoggerFunction = Callable[..., Any]
@@ -176,12 +182,50 @@ class RSESettingsDict(TypedDict):
     domain: list[str]
     protocols: list[RSEProtocolDict]
 
+    # Compatibility with protocols that access protocol-specific data from rse_settings (e.g. RFIO)
+    protocol: RSEProtocolDict
+    prefix: str
+    scheme: str
+    hostname: str
+
 
 class RSEAccountCounterDict(TypedDict):
     account: InternalAccount
     rse_id: str
 
 
+class RSEAccountUsageDict(TypedDict):
+    rse_id: str
+    rse: str
+    account: InternalAccount
+    used_files: int
+    used_bytes: int
+    quota_bytes: int
+
+
+class RSEGlobalAccountUsageDict(TypedDict):
+    rse_expression: str
+    bytes: int
+    files: int
+    bytes_limit: int
+    bytes_remaining: int
+
+
+class RSELocalAccountUsageDict(TypedDict):
+    rse_id: str
+    rse: str
+    bytes: int
+    files: int
+    bytes_limit: int
+    bytes_remaining: int
+
+
+class RSEResolvedGlobalAccountLimitDict(TypedDict):
+    resolved_rses: str
+    resolved_rse_ids: list[str]
+    limit: float
+
+
 class RuleDict(TypedDict):
     account: InternalAccount
     copies: int
@@ -197,6 +241,20 @@ class RuleDict(TypedDict):
     purge_replicas: bool
 
 
+class ReplicaDict(TypedDict):
+    scope: InternalScope
+    name: str
+    path: Optional[str]
+    state: "ReplicaState"
+    bytes: int
+    md5: Optional[str]
+    adler32: Optional[str]
+    rse_id: str
+    rse_name: str
+    rse_type: "RSEType"
+    volatile: bool
+
+
 class DIDDict(TypedDict):
     name: str
     scope: InternalScope
@@ -207,6 +265,16 @@ class DIDStringDict(TypedDict):
     scope: str
 
 
+class LFNDict(TypedDict):
+    name: str
+    scope: str
+    path: NotRequired[str]
+    filesize: NotRequired[int]
+    adler32: NotRequired[str]
+    md5: NotRequired[str]
+    filename: NotRequired[str]
+
+
 class DatasetDict(DIDStringDict):
     rse: str
 
@@ -226,18 +294,24 @@ class HopDict(TypedDict):
 
 class TokenDict(TypedDict):
     token: str
-    expires_at: datetime
+    expires_at: 'datetime'
 
 
 class TokenValidationDict(TypedDict):
     account: Optional[InternalAccount]
     identity: Optional[str]
-    lifetime: datetime
+    lifetime: 'datetime'
     audience: Optional[str]
     authz_scope: Optional[str]
 
 
 class IPDict(TypedDict):
+    ip: Optional[str]
+    fqdn: Optional[str]
+    site: Optional[str]
+
+
+class IPWithLocationDict(TypedDict):
     ip: str
     fqdn: str
     site: str
@@ -265,7 +339,7 @@ class IdentityDict(TypedDict):
 class UsageDict(TypedDict):
     bytes: int
     files: int
-    updated_at: Optional[datetime]
+    updated_at: Optional['datetime']
 
 
 class AccountUsageModelDict(TypedDict):
@@ -399,5 +473,11 @@ class RequestAttributesDict(TypedDict):
 class FilterDict(TypedDict):
     rule_id: str
     request_id: str
-    older_than: datetime
+    older_than: 'datetime'
     activities: Union[list[str], str]
+
+
+def is_str_list(in_list: list[Any]) -> TypeGuard[list[str]]:
+    """Typeguard to narrow type of list to list[str].
+    For speed, assumes that all elements are str if the first element is str."""
+    return isinstance(next(iter(in_list), None), str)