globus-cli 3.38.0__tar.gz → 3.40.0__tar.gz

{globus_cli-3.38.0/src/globus_cli.egg-info → globus_cli-3.40.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: globus-cli
-Version: 3.38.0
+Version: 3.40.0
 Summary: Globus CLI
 Author-email: Stephen Rosen <sirosen@globus.org>
 License-Expression: Apache-2.0
@@ -18,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: globus-sdk==3.63.0
+Requires-Dist: globus-sdk==4.1.0
 Requires-Dist: click<8.4,>=8.1.4
 Requires-Dist: jmespath==1.0.1
 Requires-Dist: packaging>=17.0

{globus_cli-3.38.0 → globus_cli-3.40.0}/pyproject.toml

@@ -28,7 +28,7 @@ classifiers = [
 ]
 requires-python = ">=3.9"
 dependencies = [
-    "globus-sdk==3.63.0",
+    "globus-sdk==4.1.0",
     "click>=8.1.4,<8.4",
     "jmespath==1.0.1",
     "packaging>=17.0",
@@ -49,7 +49,7 @@ globus = "globus_cli:main"
 coverage = [
     "coverage[toml]>=7.10"
 ]
-yaml = ["ruamel.yaml==0.18.15"]
+yaml = ["ruamel.yaml==0.18.16"]
 test = [
     {include-group = "coverage"},
     {include-group = "yaml"},  # loading test fixture data
@@ -96,9 +96,6 @@ profile = "black"
 addopts = "-n auto --maxprocesses 4 --dist loadscope --timeout 3 --color=yes"
 filterwarnings = [
     "error",
-    # ignore SDK warnings for 'filter_role' until
-    # 'filter_roles' update is applied
-    "ignore:The `filter_role` parameter is deprecated.:globus_sdk.exc.RemovedInV4Warning:",
 ]
 
 [tool.coverage.run]

{globus_cli-3.38.0 → globus_cli-3.40.0}/src/globus_cli/commands/api.py

@@ -7,6 +7,7 @@ from collections import defaultdict
 
 import click
 import globus_sdk
+from globus_sdk.scopes import ScopeParser
 
 from globus_cli import termio, version
 from globus_cli._click_compat import shim_get_metavar
@@ -137,7 +138,7 @@ def _get_resource_server(service_name: str) -> str:
         "groups": globus_sdk.GroupsClient.resource_server,
         "search": globus_sdk.SearchClient.resource_server,
         "transfer": globus_sdk.TransferClient.resource_server,
-        "timers": globus_sdk.TimerClient.resource_server,
+        "timers": globus_sdk.TimersClient.resource_server,
     }.get(service_name)
     if _resource_server is None:
         raise NotImplementedError(f"unrecognized service: {service_name}")
@@ -282,7 +283,7 @@ def _execute_service_command(
 
     client.app_name = version.app_name + " raw-api-command"
     if no_retry:
-        client.transport.max_retries = 0
+        client.retry_config.max_retries = 0
 
     # Prepare Query Params
     query_params_d = defaultdict(list)
@@ -316,9 +317,17 @@ def _execute_service_command(
     for header_name, header_value in header:
         headers_d[header_name] = header_value
 
-    # Strip `/v2` from Groups paths, which are auto-added by `GroupsClient`.
-    if isinstance(client, globus_sdk.GroupsClient) and path.startswith("/v2"):
-        path = path[3:]
+    # Legacy Behavior: add '/v2/' and '/v0.10/' base paths to Groups and Transfer
+    # this was inherited from globus-sdk v3
+    # removing it should be done in a controlled manner
+    if isinstance(client, globus_sdk.GroupsClient) and not path.startswith("/v2/"):
+        if path.startswith("/"):
+            path = path[1:]
+        path = f"/v2/{path}"
+    if isinstance(client, globus_sdk.TransferClient) and not path.startswith("/v0.10/"):
+        if path.startswith("/"):
+            path = path[1:]
+        path = f"/v0.10/{path}"
 
     # try sending and handle any error
     try:
@@ -342,14 +351,17 @@ def _execute_service_command(
 def _handle_scope_string(
     login_manager: LoginManager,
     resource_server: str,
-    scope_string: tuple[str, ...],
+    scope_strings: tuple[str, ...],
 ) -> None:
     if not is_client_login():
         raise click.UsageError(
             "Scope requirements (--scope-string) are currently only "
             "supported for confidential-client authorized calls."
         )
-    login_manager.add_requirement(resource_server, scope_string)
+    login_manager.add_requirement(
+        resource_server,
+        tuple(scope for s in scope_strings for scope in ScopeParser.parse(s)),
+    )
 
 
 @group("api")

{globus_cli-3.38.0 → globus_cli-3.40.0}/src/globus_cli/commands/delete.py

@@ -17,6 +17,7 @@ from globus_cli.parsing import (
     task_submission_options,
 )
 from globus_cli.termio import Field, display, err_is_terminal, term_is_interactive
+from globus_cli.utils import make_dict_json_serializable
 
 
 @command(
@@ -74,16 +75,16 @@ def delete_command(
     batch: t.TextIO | None,
     ignore_missing: bool,
     star_silent: bool,
-    recursive: bool,
+    recursive: bool | globus_sdk.MissingType,
     enable_globs: bool,
     endpoint_plus_path: tuple[uuid.UUID, str | None],
-    label: str | None,
-    submission_id: str | None,
+    label: str | globus_sdk.MissingType,
+    submission_id: str | globus_sdk.MissingType,
     dry_run: bool,
-    deadline: str | None,
+    deadline: str | globus_sdk.MissingType,
     skip_activation_check: bool,
     notify: dict[str, bool],
-    local_user: str | None,
+    local_user: str | globus_sdk.MissingType,
 ) -> None:
     """
     Submits an asynchronous task that deletes files and/or directories on the target
@@ -122,7 +123,6 @@ def delete_command(
     transfer_client = login_manager.get_transfer_client()
 
     delete_data = globus_sdk.DeleteData(
-        transfer_client,
         endpoint_id,
         label=label,
         recursive=recursive,
@@ -173,7 +173,11 @@ def delete_command(
         delete_data.add_item(path)
 
     if dry_run:
-        display(delete_data.data, response_key="DATA", fields=[Field("Path", "path")])
+        display(
+            make_dict_json_serializable(delete_data),
+            response_key="DATA",
+            fields=[Field("Path", "path")],
+        )
         # exit safely
         return
 

{globus_cli-3.38.0 → globus_cli-3.40.0}/src/globus_cli/commands/endpoint/permission/list.py

@@ -29,8 +29,7 @@ def list_command(login_manager: LoginManager, *, endpoint_id: uuid.UUID) -> None
     rules = transfer_client.endpoint_acl_list(endpoint_id)
 
     formatter = AclPrincipalFormatter(auth_client)
-    for r in rules:
-        formatter.add_item(r)
+    formatter.add_items(*rules)
 
     display(
         rules,

{globus_cli-3.38.0 → globus_cli-3.40.0}/src/globus_cli/commands/endpoint/role/list.py

@@ -41,8 +41,7 @@ def role_list(login_manager: LoginManager, *, endpoint_id: uuid.UUID) -> None:
     roles = transfer_client.endpoint_role_list(endpoint_id)
 
     formatter = RolePrincipalFormatter(login_manager.get_auth_client())
-    for r in roles:
-        formatter.add_item(r)
+    formatter.add_items(*roles)
 
     display(
         roles,

{globus_cli-3.38.0 → globus_cli-3.40.0}/src/globus_cli/commands/endpoint/search.py

@@ -3,10 +3,11 @@ from __future__ import annotations
 import typing as t
 
 import click
+import globus_sdk
 from globus_sdk.paging import Paginator
 
 from globus_cli.login_manager import LoginManager
-from globus_cli.parsing import command
+from globus_cli.parsing import OMITTABLE_STRING, OmittableChoice, command
 from globus_cli.termio import display
 from globus_cli.utils import PagingWrapper
 
@@ -70,8 +71,8 @@ $ globus endpoint search --filter-scope my-endpoints
 )
 @click.option(
     "--filter-entity-type",
-    default=None,
-    type=click.Choice(
+    default=globus_sdk.MISSING,
+    type=OmittableChoice(
         (
             "GCP_mapped_collection",
             "GCP_guest_collection",
@@ -83,12 +84,14 @@ $ globus endpoint search --filter-scope my-endpoints
     ),
     help="Filter search results to endpoints of a specific entity type.",
 )
-@click.argument("filter_fulltext", required=False)
+@click.argument(
+    "filter_fulltext", required=False, default=globus_sdk.MISSING, type=OMITTABLE_STRING
+)
 @LoginManager.requires_login("auth", "transfer")
 def endpoint_search(
     login_manager: LoginManager,
     *,
-    filter_fulltext: str | None,
+    filter_fulltext: str | globus_sdk.MissingType,
     limit: int,
     filter_owner_id: str | None,
     filter_scope: t.Literal[
@@ -109,7 +112,7 @@ def endpoint_search(
             "GCSv5_mapped_collection",
             "GCSv5_guest_collection",
         ]
-        | None
+        | globus_sdk.MissingType
     ),
 ) -> None:
     """
@@ -145,7 +148,7 @@ def endpoint_search(
         paginator(
             filter_fulltext=filter_fulltext,
             filter_scope=filter_scope,
-            filter_owner_id=owner_id,
+            filter_owner_id=owner_id if owner_id is not None else globus_sdk.MISSING,
             filter_entity_type=filter_entity_type,
         ).items(),
         limit=limit,

{globus_cli-3.38.0 → globus_cli-3.40.0}/src/globus_cli/commands/endpoint/set_subscription_id.py

@@ -50,11 +50,7 @@ def set_endpoint_subscription_id(
     """
     transfer_client = login_manager.get_transfer_client()
 
-    optional_subscription_id: str | None = (
-        None if subscription_id == "null" else subscription_id
-    )
-    res = transfer_client.put(
-        f"/endpoint/{endpoint_id}/subscription",
-        data={"subscription_id": optional_subscription_id},
+    res = transfer_client.set_subscription_id(
+        endpoint_id, None if subscription_id == "null" else subscription_id
     )
     display(res, text_mode=display.RAW, response_key="message")

{globus_cli-3.38.0 → globus_cli-3.40.0}/src/globus_cli/commands/endpoint/user_credential/_common.py

@@ -1,7 +1,9 @@
 import typing as t
 
 import click
+import globus_sdk
 
+from globus_cli.parsing import OMITTABLE_STRING
 from globus_cli.types import AnyCommand
 
 C = t.TypeVar("C", bound=AnyCommand)
@@ -30,7 +32,12 @@ def user_credential_create_and_update_params(
             f = click.argument("globus-identity")(f)
             f = click.argument("storage-gateway", type=click.UUID)(f)
 
-        f = click.option("--display-name", help="Display name for the credential.")(f)
+        f = click.option(
+            "--display-name",
+            help="Display name for the credential.",
+            default=globus_sdk.MISSING,
+            type=OMITTABLE_STRING,
+        )(f)
 
         return f
 

{globus_cli-3.38.0 → globus_cli-3.40.0}/src/globus_cli/commands/endpoint/user_credential/create/posix.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import uuid
 
+import globus_sdk
 from globus_sdk.services.gcs import UserCredentialDocument
 
 from globus_cli.login_manager import LoginManager
@@ -22,7 +23,7 @@ def posix(
     storage_gateway: uuid.UUID,
     globus_identity: str,
     local_username: str,
-    display_name: str | None,
+    display_name: str | globus_sdk.MissingType,
 ) -> None:
     """
     Create a User Credential for a POSIX storage gateway.
@@ -32,7 +33,9 @@ def posix(
 
     data = UserCredentialDocument(
         storage_gateway_id=storage_gateway,
-        identity_id=auth_client.maybe_lookup_identity_id(globus_identity),
+        identity_id=(
+            auth_client.maybe_lookup_identity_id(globus_identity) or globus_sdk.MISSING
+        ),
         username=local_username,
         display_name=display_name,
     )

{globus_cli-3.38.0 → globus_cli-3.40.0}/src/globus_cli/commands/endpoint/user_credential/create/s3.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import uuid
 
 import click
+import globus_sdk
 from globus_sdk.services.gcs import UserCredentialDocument
 
 from globus_cli.login_manager import LoginManager
@@ -27,7 +28,7 @@ def s3(
     local_username: str,
     s3_key_id: str,
     s3_secret_key: str,
-    display_name: str | None,
+    display_name: str | globus_sdk.MissingType,
 ) -> None:
     """
     Create a User Credential for an S3 Storage Gateway.
@@ -44,7 +45,9 @@ def s3(
 
     data = UserCredentialDocument(
         storage_gateway_id=storage_gateway,
-        identity_id=auth_client.maybe_lookup_identity_id(globus_identity),
+        identity_id=(
+            auth_client.maybe_lookup_identity_id(globus_identity) or globus_sdk.MISSING
+        ),
         username=local_username,
         policies=policies,
         display_name=display_name,

{globus_cli-3.38.0 → globus_cli-3.40.0}/src/globus_cli/commands/endpoint/user_credential/list.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 import uuid
 
 import click
+import globus_sdk
 
 from globus_cli.login_manager import LoginManager
-from globus_cli.parsing import command, endpoint_id_arg
+from globus_cli.parsing import OMITTABLE_UUID, command, endpoint_id_arg
 from globus_cli.termio import Field, display, formatters
 
 
@@ -13,8 +14,8 @@ from globus_cli.termio import Field, display, formatters
 @endpoint_id_arg
 @click.option(
     "--storage-gateway",
-    default=None,
-    type=click.UUID,
+    default=globus_sdk.MISSING,
+    type=OMITTABLE_UUID,
     help=(
         "Filter results to User Credentials on a Storage Gateway specified by "
         "this UUID"
@@ -25,7 +26,7 @@ def user_credential_list(
     login_manager: LoginManager,
     *,
     endpoint_id: uuid.UUID,
-    storage_gateway: uuid.UUID | None,
+    storage_gateway: uuid.UUID | globus_sdk.MissingType,
 ) -> None:
     """
     List all of your User Credentials on a Globus Connect Server v5 Endpoint.

globus_cli-3.40.0/src/globus_cli/commands/flows/_common.py

@@ -0,0 +1,284 @@
+from __future__ import annotations
+
+import contextlib
+import functools
+import typing as t
+import uuid
+
+import click
+import globus_sdk
+import globus_sdk.gare
+import globus_sdk.scopes
+
+from globus_cli.login_manager import LoginManager
+from globus_cli.parsing import OMITTABLE_STRING, JSONStringOrFile
+from globus_cli.utils import CLIAuthRequirementsError
+
+_input_schema_helptext = """
+        The JSON input schema that governs the parameters
+        used to start the flow.
+
+        The input document may be specified inline, or it may be a path to a JSON file.
+
+        Example: Inline JSON:
+
+        \b
+            --input-schema '{"properties": {"src": {"type": "string"}}}'
+
+        Example: Path to JSON file:
+
+        \b
+            --input-schema schema.json
+    """
+
+input_schema_option = click.option(
+    "--input-schema",
+    "input_schema",
+    type=JSONStringOrFile(),
+    help=_input_schema_helptext,
+)
+
+input_schema_option_with_default = click.option(
+    "--input-schema",
+    "input_schema",
+    type=JSONStringOrFile(),
+    help=_input_schema_helptext
+    + "\n    If unspecified, the default is an empty JSON object ('{}').",
+)
+
+subtitle_option = click.option(
+    "--subtitle",
+    type=OMITTABLE_STRING,
+    help="A concise summary of the flow's purpose.",
+    default=globus_sdk.MISSING,
+)
+
+
+description_option = click.option(
+    "--description",
+    type=OMITTABLE_STRING,
+    help="A detailed description of the flow's purpose.",
+    default=globus_sdk.MISSING,
+)
+
+
+administrators_option = click.option(
+    "--administrator",
+    "administrators",
+    type=str,
+    multiple=True,
+    help="""
+        A principal that may perform administrative operations
+        on the flow (e.g., update, delete).
+
+        This option can be specified multiple times
+        to create a list of flow administrators.
+    """,
+)
+
+
+starters_option = click.option(
+    "--starter",
+    "starters",
+    type=str,
+    multiple=True,
+    help="""
+        A principal that may start a new run of the flow.
+
+        Use "all_authenticated_users" to allow any authenticated user
+        to start a new run of the flow.
+
+        This option can be specified multiple times
+        to create a list of flow starters.
+    """,
+)
+
+
+viewers_option = click.option(
+    "--viewer",
+    "viewers",
+    type=str,
+    multiple=True,
+    help="""
+        A principal that may view the flow.
+
+        Use "public" to make the flow visible to everyone.
+
+        This option can be specified multiple times
+        to create a list of flow viewers.
+    """,
+)
+
+
+keywords_option = click.option(
+    "--keyword",
+    "keywords",
+    type=str,
+    multiple=True,
+    help="""
+        A term used to help discover this flow when
+        browsing and searching.
+
+        This option can be specified multiple times
+        to create a list of keywords.
+    """,
+)
+
+
+class SubscriptionIdType(click.ParamType):
+    name = "SUBSCRIPTION_ID"
+
+    def __init__(self, *, omittable: bool = False) -> None:
+        self._omittable = omittable
+
+    def convert(
+        self, value: t.Any, param: click.Parameter | None, ctx: click.Context | None
+    ) -> uuid.UUID | t.Literal["DEFAULT"] | globus_sdk.MissingType:
+        if self._omittable and value is globus_sdk.MISSING:
+            return globus_sdk.MISSING
+
+        if value.upper() == "DEFAULT":
+            return "DEFAULT"
+        try:
+            return uuid.UUID(value)
+        except ValueError:
+            self.fail(f"{value} must be either a UUID or 'DEFAULT'", param, ctx)
+
+    def get_type_annotation(self, param: click.Parameter) -> type:
+        if self._omittable:
+            return t.Union[  # type: ignore[return-value]
+                uuid.UUID, t.Literal["DEFAULT"], globus_sdk.MissingType
+            ]
+        return t.Union[uuid.UUID, t.Literal["DEFAULT"]]  # type: ignore[return-value]
+
+
+subscription_id_option = click.option(
+    "--subscription-id",
+    "subscription_id",
+    type=SubscriptionIdType(omittable=True),
+    multiple=False,
+    help="""
+        A subscription ID to assign to the flow.
+
+        The value may be a UUID or the word "DEFAULT".
+    """,
+    default=globus_sdk.MISSING,
+)
+
+
+class FlowScopeInjector:
+    """
+    A context manager for injecting flow-specific scopes into raised GAREs.
+
+    Usage (flow api):
+    >>> with FlowScopeInjector(login_manager).for_flow(flow_id):
+    >>>     flows_client.get_flow(flow_id)
+
+    Usage (run api):
+    >>> with FlowScopeInjector(login_manager).for_run(run_id):
+    >>>     flows_client.get_run(run_id)
+
+    In either case, if the function call raises a GARE-compatible GlobusAPIError,
+    the context manager will inject the appropriate flow-specific scope into the
+    GARE's required scope section, reraising it as a CLIAuthRequirementsError.
+
+    Using this ensures that the suggested remediation command will update the relevant
+    specific-flow's token, not just the statically-registered flows tokens.
+    This can resolve issues where a user, for instance, prints out an HA flow, then
+    attempts to run it.
+    """
+
+    def __init__(self, login_manager: LoginManager) -> None:
+        self._login_manager = login_manager
+
+    @contextlib.contextmanager
+    def for_flow(self, flow_id: uuid.UUID) -> t.Iterator[None]:
+        """
+        Context Manager to wrap a flow operation.
+
+        If the wrapped operation raises a GARE, this manager will re-raise it
+        with the flow-specific scope injected.
+        """
+        try:
+            yield
+        except globus_sdk.GlobusAPIError as api_error:
+            self._inject_and_raise(api_error, lambda: flow_id)
+
+    @contextlib.contextmanager
+    def for_run(self, run_id: uuid.UUID) -> t.Iterator[None]:
+        """
+        Context manager to wrap a flow run operation.
+
+        If the wrapped operation raises a GARE, this manager will attempt to look up
+        the associated flow ID from search & re-raise it with the flow-specific scope.
+
+        If the lookup fails, the original error is raised unmodified.
+        """
+        try:
+            yield
+        except globus_sdk.GlobusAPIError as api_error:
+            resolver = FlowIdResolver(self._login_manager)
+            resolve_flow_id = functools.partial(resolver.resolve, run_id)
+
+            self._inject_and_raise(api_error, resolve_flow_id)
+
+    @staticmethod
+    def _inject_and_raise(
+        api_error: globus_sdk.GlobusAPIError,
+        resolve_flow_id: t.Callable[[], uuid.UUID | None],
+    ) -> None:
+        """
+        :raises GlobusAPIError: if the supplied api error is not GARE-compatible
+        :raises CLIAuthRequirementsError: otherwise with the flow-scope injected into
+            the required scopes (assuming it wasn't already there).
+        """
+        if (gare := globus_sdk.gare.to_gare(api_error)) is None or (
+            (flow_id := resolve_flow_id()) is None
+        ):
+            raise api_error
+
+        flow_scope = globus_sdk.scopes.SpecificFlowScopes(flow_id).user.scope_string
+
+        required_scopes = gare.authorization_parameters.required_scopes or []
+        # Make sure that no root scopes match the one we want to inject.
+        if not any(s.startswith(flow_scope) for s in required_scopes):
+            required_scopes.insert(0, flow_scope)
+        gare.authorization_parameters.required_scopes = required_scopes
+
+        raise CLIAuthRequirementsError("", gare=gare, origin=api_error)
+
+
+class FlowIdResolver:
+    RUN_INDEX = "2a318659-a547-4b48-a0fc-e0c19081a960"
+
+    def __init__(self, login_manager: LoginManager) -> None:
+        self._search_client = login_manager.get_search_client()
+
+    def resolve(self, run_id: uuid.UUID) -> uuid.UUID | None:
+        """
+        Lookup a run's associated flow ID from search (best-effort).
+
+        :return: The flow ID as a UUID, or None if the lookup fails or is unparsable
+            for any reason.
+        """
+
+        try:
+            flow_id = self._search_client.post_search(
+                self.RUN_INDEX,
+                {
+                    "filters": [
+                        {
+                            "type": "match_any",
+                            "field_name": "run_id",
+                            "values": [str(run_id)],
+                        }
+                    ],
+                    "limit": 1,
+                },
+            )["gmeta"][0]["entries"][0]["content"]["flow_id"]
+            return uuid.UUID(flow_id)
+        except (globus_sdk.GlobusError, LookupError):
+            # This search is a best-effort flows-operation.
+            # To avoid mis-categorizing a flows error as a search one, silence any
+            #   predictable error arising from a failed lookup.
+            return None