rucio 32.8.6__py3-none-any.whl → 35.8.0__py3-none-any.whl

rucio/{api → gateway}/rule.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,23 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Literal, Optional
 
-from rucio.api.permission import has_permission
 from rucio.common.config import config_get_bool
 from rucio.common.exception import AccessDenied
 from rucio.common.schema import validate_schema
 from rucio.common.types import InternalAccount, InternalScope
-from rucio.common.utils import api_update_return_dict
+from rucio.common.utils import gateway_update_return_dict
 from rucio.core import rule
 from rucio.db.sqla.session import read_session, stream_session, transactional_session
+from rucio.gateway.permission import has_permission
 
 if TYPE_CHECKING:
+    from collections.abc import Iterator, Sequence
+
     from sqlalchemy.orm import Session
 
 
 @read_session
-def is_multi_vo(*, session: "Session"):
+def is_multi_vo(*, session: "Session") -> bool:
     """
     Check whether this instance is configured for multi-VO
     returns: Boolean True if running in multi-VO
@@ -38,9 +39,33 @@ def is_multi_vo(*, session: "Session"):
 
 
 @transactional_session
-def add_replication_rule(dids, copies, rse_expression, weight, lifetime, grouping, account, locked, subscription_id, source_replica_expression,
-                         activity, notify, purge_replicas, ignore_availability, comment, ask_approval, asynchronous, delay_injection, priority,
-                         split_container, meta, issuer, vo='def', *, session: "Session"):
+def add_replication_rule(
+    dids: "Sequence[dict[str, str]]",
+    copies: int,
+    rse_expression: str,
+    weight: Optional[str],
+    lifetime: Optional[int],
+    grouping: Literal['ALL', 'DATASET', 'NONE'],
+    account: str,
+    locked: bool,
+    subscription_id: Optional[str],
+    source_replica_expression: Optional[str],
+    activity: Optional[str],
+    notify: Optional[Literal['Y', 'N', 'C', 'P']],
+    purge_replicas: bool,
+    ignore_availability: bool,
+    comment: Optional[str],
+    ask_approval: bool,
+    asynchronous: bool,
+    delay_injection: Optional[int],
+    priority: int,
+    split_container: bool,
+    meta: Optional[dict[str, Any]],
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> list[str]:
     """
     Adds a replication rule.
 
@@ -89,12 +114,11 @@ def add_replication_rule(dids, copies, rse_expression, weight, lifetime, groupin
     if not has_permission(issuer=issuer, vo=vo, action='add_rule', kwargs=kwargs, session=session):
         raise AccessDenied('Account %s can not add replication rule' % (issuer))
 
-    account = InternalAccount(account, vo=vo)
-    for d in dids:
-        d['scope'] = InternalScope(d['scope'], vo=vo)
+    account_internal = InternalAccount(account, vo=vo)
+    dids_with_internal_scope = [{'name': d['name'], 'scope': InternalScope(d['scope'], vo=vo)} for d in dids]
 
-    return rule.add_rule(account=account,
-                         dids=dids,
+    return rule.add_rule(account=account_internal,
+                         dids=dids_with_internal_scope,
                          copies=copies,
                          rse_expression=rse_expression,
                          grouping=grouping,
@@ -118,7 +142,7 @@ def add_replication_rule(dids, copies, rse_expression, weight, lifetime, groupin
 
 
 @read_session
-def get_replication_rule(rule_id, issuer, vo='def', *, session: "Session"):
+def get_replication_rule(rule_id: str, issuer: str, vo: str = 'def', *, session: "Session") -> dict[str, Any]:
     """
     Get replication rule by it's id.
 
@@ -131,11 +155,16 @@ def get_replication_rule(rule_id, issuer, vo='def', *, session: "Session"):
     if is_multi_vo(session=session) and not has_permission(issuer=issuer, vo=vo, action='access_rule_vo', kwargs=kwargs, session=session):
         raise AccessDenied('Account %s can not access rules at other VOs.' % (issuer))
     result = rule.get_rule(rule_id, session=session)
-    return api_update_return_dict(result, session=session)
+    return gateway_update_return_dict(result, session=session)
 
 
 @stream_session
-def list_replication_rules(filters={}, vo='def', *, session: "Session"):
+def list_replication_rules(
+    filters: Optional[dict[str, Any]] = None,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> "Iterator[dict[str, Any]]":
     """
     Lists replication rules based on a filter.
 
@@ -144,8 +173,7 @@ def list_replication_rules(filters={}, vo='def', *, session: "Session"):
     :param session: The database session in use.
     """
     # If filters is empty, create a new dict to avoid overwriting the function's default
-    if not filters:
-        filters = {}
+    filters = filters or {}
 
     if 'scope' in filters:
         scope = filters['scope']
@@ -161,11 +189,17 @@ def list_replication_rules(filters={}, vo='def', *, session: "Session"):
 
     rules = rule.list_rules(filters, session=session)
     for r in rules:
-        yield api_update_return_dict(r, session=session)
+        yield gateway_update_return_dict(r, session=session)
 
 
 @read_session
-def list_replication_rule_history(rule_id, issuer, vo='def', *, session: "Session"):
+def list_replication_rule_history(
+    rule_id: str,
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> "Iterator[dict[str, Any]]":
     """
     Lists replication rule history..
 
@@ -181,7 +215,13 @@ def list_replication_rule_history(rule_id, issuer, vo='def', *, session: "Sessio
 
 
 @stream_session
-def list_replication_rule_full_history(scope, name, vo='def', *, session: "Session"):
+def list_replication_rule_full_history(
+    scope: str,
+    name: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> "Iterator[dict[str, Any]]":
     """
     List the rule history of a DID.
 
@@ -190,14 +230,20 @@ def list_replication_rule_full_history(scope, name, vo='def', *, session: "Sessi
     :param vo: The VO to act on.
     :param session: The database session in use.
     """
-    scope = InternalScope(scope, vo=vo)
-    rules = rule.list_rule_full_history(scope, name, session=session)
+    scope_internal = InternalScope(scope, vo=vo)
+    rules = rule.list_rule_full_history(scope_internal, name, session=session)
     for r in rules:
-        yield api_update_return_dict(r, session=session)
+        yield gateway_update_return_dict(r, session=session)
 
 
 @stream_session
-def list_associated_replication_rules_for_file(scope, name, vo='def', *, session: "Session"):
+def list_associated_replication_rules_for_file(
+    scope: str,
+    name: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> "Iterator[dict[str, Any]]":
     """
     Lists associated replication rules by file.
 
@@ -206,14 +252,21 @@ def list_associated_replication_rules_for_file(scope, name, vo='def', *, session
     :param vo: The VO to act on.
     :param session: The database session in use.
     """
-    scope = InternalScope(scope, vo=vo)
-    rules = rule.list_associated_rules_for_file(scope=scope, name=name, session=session)
+    scope_internal = InternalScope(scope, vo=vo)
+    rules = rule.list_associated_rules_for_file(scope=scope_internal, name=name, session=session)
     for r in rules:
-        yield api_update_return_dict(r, session=session)
+        yield gateway_update_return_dict(r, session=session)
 
 
 @transactional_session
-def delete_replication_rule(rule_id, purge_replicas, issuer, vo='def', *, session: "Session"):
+def delete_replication_rule(
+    rule_id: str,
+    purge_replicas: Optional[bool],
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> None:
     """
     Deletes a replication rule and all associated locks.
 
@@ -233,7 +286,14 @@ def delete_replication_rule(rule_id, purge_replicas, issuer, vo='def', *, sessio
 
 
 @transactional_session
-def update_replication_rule(rule_id: str, options: dict[str, Any], issuer: str, vo: str = 'def', *, session: "Session"):
+def update_replication_rule(
+    rule_id: str,
+    options: dict[str, Any],
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> None:
     """
     Update lock state of a replication rule.
 
@@ -265,7 +325,15 @@ def update_replication_rule(rule_id: str, options: dict[str, Any], issuer: str,
 
 
 @transactional_session
-def reduce_replication_rule(rule_id, copies, exclude_expression, issuer, vo='def', *, session: "Session"):
+def reduce_replication_rule(
+    rule_id: str,
+    copies: int,
+    exclude_expression: Optional[str],
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> str:
     """
     Reduce the number of copies for a rule by atomically replacing the rule.
 
@@ -287,7 +355,13 @@ def reduce_replication_rule(rule_id, copies, exclude_expression, issuer, vo='def
 
 
 @read_session
-def examine_replication_rule(rule_id, issuer, vo='def', *, session: "Session"):
+def examine_replication_rule(
+    rule_id: str,
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> dict[str, Any]:
     """
     Examine a replication rule.
 
@@ -300,14 +374,22 @@ def examine_replication_rule(rule_id, issuer, vo='def', *, session: "Session"):
     if is_multi_vo(session=session) and not has_permission(issuer=issuer, vo=vo, action='access_rule_vo', kwargs=kwargs, session=session):
         raise AccessDenied('Account %s can not access rules at other VOs.' % (issuer))
     result = rule.examine_rule(rule_id, session=session)
-    result = api_update_return_dict(result, session=session)
+    result = gateway_update_return_dict(result, session=session)
     if 'transfers' in result:
-        result['transfers'] = [api_update_return_dict(t, session=session) for t in result['transfers']]
+        result['transfers'] = [gateway_update_return_dict(t, session=session) for t in result['transfers']]
     return result
 
 
 @transactional_session
-def move_replication_rule(rule_id, rse_expression, override, issuer, vo='def', *, session: "Session"):
+def move_replication_rule(
+    rule_id: str,
+    rse_expression: str,
+    override: dict[str, Any],
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> str:
     """
     Move a replication rule to another RSE and, once done, delete the original one.
 

rucio/{api → gateway}/scope.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional
 
-import rucio.api.permission
 import rucio.common.exception
+import rucio.gateway.permission
 from rucio.common.schema import validate_schema
 from rucio.common.types import InternalAccount, InternalScope
 from rucio.core import scope as core_scope
@@ -27,7 +26,7 @@ if TYPE_CHECKING:
 
 
 @read_session
-def list_scopes(filter_={}, vo='def', *, session: "Session"):
+def list_scopes(filter_: Optional[dict[str, Any]] = None, vo: str = 'def', *, session: "Session") -> list[str]:
     """
     Lists all scopes.
 
@@ -38,8 +37,7 @@ def list_scopes(filter_={}, vo='def', *, session: "Session"):
     :returns: A list containing all scopes.
     """
     # If filter is empty, create a new dict to avoid overwriting the function's default
-    if not filter_:
-        filter_ = {}
+    filter_ = filter_ or {}
 
     if 'scope' in filter_:
         filter_['scope'] = InternalScope(scope=filter_['scope'], vo=vo)
@@ -49,7 +47,14 @@ def list_scopes(filter_={}, vo='def', *, session: "Session"):
 
 
 @transactional_session
-def add_scope(scope, account, issuer, vo='def', *, session: "Session"):
+def add_scope(
+    scope: str,
+    account: str,
+    issuer: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> None:
     """
     Creates a scope for an account.
 
@@ -63,17 +68,22 @@ def add_scope(scope, account, issuer, vo='def', *, session: "Session"):
     validate_schema(name='scope', obj=scope, vo=vo)
 
     kwargs = {'scope': scope, 'account': account}
-    if not rucio.api.permission.has_permission(issuer=issuer, vo=vo, action='add_scope', kwargs=kwargs, session=session):
+    if not rucio.gateway.permission.has_permission(issuer=issuer, vo=vo, action='add_scope', kwargs=kwargs, session=session):
         raise rucio.common.exception.AccessDenied('Account %s can not add scope' % (issuer))
 
-    scope = InternalScope(scope, vo=vo)
-    account = InternalAccount(account, vo=vo)
+    internal_scope = InternalScope(scope, vo=vo)
+    internal_account = InternalAccount(account, vo=vo)
 
-    core_scope.add_scope(scope, account, session=session)
+    core_scope.add_scope(internal_scope, internal_account, session=session)
 
 
 @read_session
-def get_scopes(account, vo='def', *, session: "Session"):
+def get_scopes(
+    account: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> list[str]:
     """
     Gets a list of all scopes for an account.
 
@@ -84,6 +94,6 @@ def get_scopes(account, vo='def', *, session: "Session"):
     :returns: A list containing the names of all scopes for this account.
     """
 
-    account = InternalAccount(account, vo=vo)
+    internal_account = InternalAccount(account, vo=vo)
 
-    return [scope.external for scope in core_scope.get_scopes(account, session=session)]
+    return [scope.external for scope in core_scope.get_scopes(internal_account, session=session)]

rucio/{api → gateway}/subscription.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,15 +13,16 @@
 # limitations under the License.
 
 from collections import namedtuple
+from collections.abc import Iterator
 from json import dumps, loads
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Literal, Optional, Union
 
-from rucio.api.permission import has_permission
-from rucio.common.exception import InvalidObject, AccessDenied
+from rucio.common.exception import AccessDenied, InvalidObject
 from rucio.common.schema import validate_schema
 from rucio.common.types import InternalAccount, InternalScope
 from rucio.core import subscription
 from rucio.db.sqla.session import read_session, stream_session, transactional_session
+from rucio.gateway.permission import has_permission
 
 if TYPE_CHECKING:
     from sqlalchemy.orm import Session
@@ -32,36 +32,38 @@ SubscriptionRuleState = namedtuple('SubscriptionRuleState', ['account', 'name',
 
 
 @transactional_session
-def add_subscription(name, account, filter_, replication_rules, comments, lifetime, retroactive, dry_run, priority=None, issuer=None, vo='def', *, session: "Session"):
+def add_subscription(
+    name: str,
+    account: str,
+    filter_: dict[str, Any],
+    replication_rules: list[dict[str, Any]],
+    comments: str,
+    lifetime: Union[int, Literal[False]],
+    retroactive: bool,
+    dry_run: bool,
+    priority: Optional[int] = None,
+    issuer: Optional[str] = None,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> str:
     """
     Adds a new subscription which will be verified against every new added file and dataset
 
     :param account: Account identifier
-    :type account:  String
     :param name: Name of the subscription
-    :type:  String
     :param filter_: Dictionary of attributes by which the input data should be filtered
                    **Example**: ``{'dsn': 'data11_hi*.express_express.*,data11_hi*physics_MinBiasOverlay*', 'account': 'tzero'}``
-    :type filter_:  Dict
     :param replication_rules: Replication rules to be set : Dictionary with keys copies, rse_expression, weight, rse_expression
-    :type replication_rules:  Dict
     :param comments: Comments for the subscription
-    :type comments:  String
     :param lifetime: Subscription's lifetime (seconds); False if subscription has no lifetime
-    :type lifetime:  Integer or False
     :param retroactive: Flag to know if the subscription should be applied on previous data
-    :type retroactive:  Boolean
     :param dry_run: Just print the subscriptions actions without actually executing them (Useful if retroactive flag is set)
-    :type dry_run:  Boolean
     :param priority: The priority of the subscription
-    :type priority: Integer
     :param issuer:  The account issuing this operation.
-    :type issuer:  String
     :param vo: The VO to act on.
-    :type vo: String
     :param session: The database session in use.
     :returns: subscription_id
-    :rtype:   String
     """
     if not has_permission(issuer=issuer, vo=vo, action='add_subscription', kwargs={'account': account}, session=session):
         raise AccessDenied('Account %s can not add subscription' % (issuer))
@@ -81,7 +83,7 @@ def add_subscription(name, account, filter_, replication_rules, comments, lifeti
     except ValueError as error:
         raise TypeError(error)
 
-    account = InternalAccount(account, vo=vo)
+    internal_account = InternalAccount(account, vo=vo)
 
     keys = ['scope', 'account']
     types = [InternalScope, InternalAccount]
@@ -92,26 +94,29 @@ def add_subscription(name, account, filter_, replication_rules, comments, lifeti
             else:
                 filter_[_key] = _type(filter_[_key], vo=vo).internal
 
-    return subscription.add_subscription(name=name, account=account, filter_=dumps(filter_), replication_rules=dumps(replication_rules),
+    return subscription.add_subscription(name=name, account=internal_account, filter_=dumps(filter_), replication_rules=dumps(replication_rules),
                                          comments=comments, lifetime=lifetime, retroactive=retroactive, dry_run=dry_run, priority=priority,
                                          session=session)
 
 
 @transactional_session
-def update_subscription(name, account, metadata=None, issuer=None, vo='def', *, session: "Session"):
+def update_subscription(
+    name: str,
+    account: str,
+    metadata: Optional[dict[str, Any]] = None,
+    issuer: Optional[str] = None,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> None:
     """
     Updates a subscription
 
     :param name: Name of the subscription
-    :type:  String
     :param account: Account identifier
-    :type account:  String
     :param metadata: Dictionary of metadata to update. Supported keys : filter, replication_rules, comments, lifetime, retroactive, dry_run, priority, last_processed
-    :type metadata:  Dict
     :param issuer: The account issuing this operation.
-    :type issuer: String
     :param vo: The VO to act on.
-    :type vo: String
     :param session: The database session in use.
     :raises: SubscriptionNotFound if subscription is not found
     """
@@ -133,7 +138,7 @@ def update_subscription(name, account, metadata=None, issuer=None, vo='def', *,
     except ValueError as error:
         raise TypeError(error)
 
-    account = InternalAccount(account, vo=vo)
+    internal_account = InternalAccount(account, vo=vo)
 
     if 'filter' in metadata and metadata['filter'] is not None:
         filter_ = metadata['filter']
@@ -147,35 +152,37 @@ def update_subscription(name, account, metadata=None, issuer=None, vo='def', *,
                 else:
                     filter_[_key] = _type(filter_[_key], vo=vo).internal
 
-    return subscription.update_subscription(name=name, account=account, metadata=metadata, session=session)
+    return subscription.update_subscription(name=name, account=internal_account, metadata=metadata, session=session)
 
 
 @stream_session
-def list_subscriptions(name=None, account=None, state=None, vo='def', *, session: "Session"):
+def list_subscriptions(
+    name: Optional[str] = None,
+    account: Optional[str] = None,
+    state: Optional[str] = None,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> Iterator[dict[str, Any]]:
     """
     Returns a dictionary with the subscription information :
     Examples: ``{'status': 'INACTIVE/ACTIVE/BROKEN', 'last_modified_date': ...}``
 
     :param name: Name of the subscription
-    :type:  String
     :param account: Account identifier
-    :type account:  String
     :param state: Filter for subscription state
-    :type state: String
     :param vo: The VO to act on.
-    :type vo: String
     :param session: The database session in use.
     :returns: Dictionary containing subscription parameter
-    :rtype:   Dict
     :raises: exception.NotFound if subscription is not found
     """
 
     if account:
-        account = InternalAccount(account, vo=vo)
+        internal_account = InternalAccount(account, vo=vo)
     else:
-        account = InternalAccount('*', vo=vo)
+        internal_account = InternalAccount('*', vo=vo)
 
-    subs = subscription.list_subscriptions(name, account, state, session=session)
+    subs = subscription.list_subscriptions(name, internal_account, state, session=session)
 
     for sub in subs:
         sub['account'] = sub['account'].external
@@ -192,7 +199,13 @@ def list_subscriptions(name=None, account=None, state=None, vo='def', *, session
 
 
 @stream_session
-def list_subscription_rule_states(name=None, account=None, vo='def', *, session: "Session"):
+def list_subscription_rule_states(
+    name: Optional[str] = None,
+    account: Optional[str] = None,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> Iterator[SubscriptionRuleState]:
     """Returns a list of with the number of rules per state for a subscription.
 
     :param name: Name of the subscription
@@ -202,10 +215,10 @@ def list_subscription_rule_states(name=None, account=None, vo='def', *, session:
     :returns: Sequence with SubscriptionRuleState named tuples (account, name, state, count)
     """
     if account is not None:
-        account = InternalAccount(account, vo=vo)
+        internal_account = InternalAccount(account, vo=vo)
     else:
-        account = InternalAccount('*', vo=vo)
-    subs = subscription.list_subscription_rule_states(name, account, session=session)
+        internal_account = InternalAccount('*', vo=vo)
+    subs = subscription.list_subscription_rule_states(name, internal_account, session=session)
     for sub in subs:
         # sub is an immutable Row so return new named tuple with edited entries
         d = sub._asdict()
@@ -214,21 +227,30 @@ def list_subscription_rule_states(name=None, account=None, vo='def', *, session:
 
 
 @transactional_session
-def delete_subscription(subscription_id, vo='def', *, session: "Session"):
+def delete_subscription(
+    subscription_id: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> None:
     """
     Deletes a subscription
 
     :param subscription_id: Subscription identifier
     :param vo: The VO of the user issuing command
     :param session: The database session in use.
-    :type subscription_id:  String
     """
 
     raise NotImplementedError
 
 
 @read_session
-def get_subscription_by_id(subscription_id, vo='def', *, session: "Session"):
+def get_subscription_by_id(
+    subscription_id: str,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> dict[str, Any]:
     """
     Get a specific subscription by id.
 

rucio/{api → gateway}/vo.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,9 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional
 
-from rucio.api.permission import has_permission
 from rucio.common import exception
 from rucio.common.schema import validate_schema
 from rucio.common.types import InternalAccount
@@ -23,13 +21,14 @@ from rucio.core import identity
 from rucio.core import vo as vo_core
 from rucio.db.sqla.constants import IdentityType
 from rucio.db.sqla.session import read_session, transactional_session
+from rucio.gateway.permission import has_permission
 
 if TYPE_CHECKING:
     from sqlalchemy.orm import Session
 
 
 @transactional_session
-def add_vo(new_vo, issuer, description=None, email=None, vo='def', *, session: "Session"):
+def add_vo(new_vo: str, issuer: str, description: Optional[str] = None, email: Optional[str] = None, vo: str = 'def', *, session: "Session") -> None:
     '''
     Add a new VO.
 
@@ -52,7 +51,7 @@ def add_vo(new_vo, issuer, description=None, email=None, vo='def', *, session: "
 
 
 @read_session
-def list_vos(issuer, vo='def', *, session: "Session"):
+def list_vos(issuer: str, vo: str = 'def', *, session: "Session") -> list[dict[str, Any]]:
     '''
     List the VOs.
 
@@ -68,7 +67,18 @@ def list_vos(issuer, vo='def', *, session: "Session"):
 
 
 @transactional_session
-def recover_vo_root_identity(root_vo, identity_key, id_type, email, issuer, default=False, password=None, vo='def', *, session: "Session"):
+def recover_vo_root_identity(
+    root_vo: str,
+    identity_key: str,
+    id_type: str,
+    email: str,
+    issuer: str,
+    default: bool = False,
+    password: Optional[str] = None,
+    vo: str = 'def',
+    *,
+    session: "Session"
+) -> None:
     """
     Adds a membership association between identity and the root account for given VO.
 
@@ -94,7 +104,7 @@ def recover_vo_root_identity(root_vo, identity_key, id_type, email, issuer, defa
 
 
 @transactional_session
-def update_vo(updated_vo, parameters, issuer, vo='def', *, session: "Session"):
+def update_vo(updated_vo: str, parameters: dict[str, Any], issuer: str, vo: str = 'def', *, session: "Session") -> None:
     """
     Update VO properties (email, description).