globus-cli 3.33.0__tar.gz → 3.34.0__tar.gz

{globus_cli-3.33.0/src/globus_cli.egg-info → globus_cli-3.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: globus-cli
-Version: 3.33.0
+Version: 3.34.0
 Summary: Globus CLI
 Author-email: Stephen Rosen <sirosen@globus.org>
 Project-URL: homepage, https://github.com/globus/globus-cli
@@ -19,12 +19,13 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: globus-sdk==3.51.0
+Requires-Dist: globus-sdk==3.55.0
 Requires-Dist: click<9,>=8.1.4
 Requires-Dist: jmespath==1.0.1
 Requires-Dist: packaging>=17.0
 Requires-Dist: typing_extensions>=4.0; python_version < "3.11"
 Requires-Dist: requests<3.0.0,>=2.32.3
+Dynamic: license-file
 
 .. image:: https://github.com/globus/globus-cli/workflows/build/badge.svg?event=push
     :alt: build status

{globus_cli-3.33.0 → globus_cli-3.34.0}/pyproject.toml

@@ -29,7 +29,7 @@ classifiers = [
 ]
 requires-python = ">=3.8"
 dependencies = [
-    "globus-sdk==3.51.0",
+    "globus-sdk==3.55.0",
     "click>=8.1.4,<9",
     "jmespath==1.0.1",
     "packaging>=17.0",
@@ -56,7 +56,7 @@ test = [
     "pytest-xdist<4",
     "pytest-timeout<3",
     "click-type-test==1.1.0;python_version>='3.10'",
-    "responses==0.25.6",
+    "responses==0.25.7",
     # loading test fixture data
     "ruamel.yaml==0.18.10",
 ]

{globus_cli-3.33.0 → globus_cli-3.34.0}/src/globus_cli/commands/api.py

@@ -134,7 +134,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,
-        "timer": globus_sdk.TimerClient.resource_server,
+        "timers": globus_sdk.TimerClient.resource_server,
     }.get(service_name)
     if _resource_server is None:
         raise NotImplementedError(f"unrecognized service: {service_name}")
@@ -154,7 +154,7 @@ def _get_client(
         return login_manager.get_search_client()
     elif service_name == "transfer":
         return login_manager.get_transfer_client()
-    elif service_name == "timer":
+    elif service_name == "timers":
         return login_manager.get_timer_client()
     else:
         raise NotImplementedError(f"unrecognized service: {service_name}")
@@ -167,7 +167,7 @@ def _get_url(service_name: str) -> str:
         "groups": "https://groups.api.globus.org/v2/",
         "search": "https://search.api.globus.org/",
         "transfer": "https://transfer.api.globus.org/v0.10/",
-        "timer": "https://timer.automate.globus.org/",
+        "timers": "https://timer.automate.globus.org/",
         "gcs": "https://$GCS_MANAGER/",
     }[service_name]
 
@@ -356,7 +356,14 @@ def api_command() -> None:
 
 # note: this must be written as a separate call and not inlined into the loop body
 # this ensures that it acts as a closure over 'service_name'
-def build_command(service_name: ServiceNameLiteral | t.Literal["gcs"]) -> click.Command:
+def build_command(
+    command_name: ServiceNameLiteral | t.Literal["gcs", "timer"],
+) -> click.Command:
+    service_name: ServiceNameLiteral | t.Literal["gcs"] = (
+        "timers" if command_name == "timer" else command_name
+    )
+    hidden: bool = command_name == "timer"
+
     helptext = f"""\
 Make API calls to Globus {service_name.title()}
 
@@ -364,14 +371,14 @@ The arguments are an HTTP method name and a path within the service to which the
 should be made. The path will be joined with the known service URL.
 For example, a call of
 
-    globus api {service_name} GET /foo/bar
+    globus api {command_name} GET /foo/bar
 
-sends a 'GET' request to '{_get_url(service_name)}foo/bar'
+sends a 'GET' request to `{_get_url(service_name)}foo/bar`
 """
 
     if service_name != "gcs":
 
-        @command(service_name, help=helptext)
+        @command(command_name, help=helptext, hidden=hidden)
         @LoginManager.requires_login(service_name)
         @_service_command_params
         def service_command(
@@ -457,3 +464,4 @@ for service_name_ in CLI_SCOPE_REQUIREMENTS:
 del service_name_
 
 api_command.add_command(build_command("gcs"))
+api_command.add_command(build_command("timer"))

{globus_cli-3.33.0 → globus_cli-3.34.0}/src/globus_cli/commands/search/index/list.py

@@ -15,8 +15,5 @@ def list_command(login_manager: LoginManager) -> None:
     """List indices where you have some permissions."""
     search_client = login_manager.get_search_client()
     display(
-        search_client.get("/v1/index_list"),
-        fields=INDEX_LIST_FIELDS,
-        text_mode=display.TABLE,
-        response_key="index_list",
+        search_client.index_list(), fields=INDEX_LIST_FIELDS, text_mode=display.TABLE
     )

{globus_cli-3.33.0 → globus_cli-3.34.0}/src/globus_cli/commands/task/list.py

@@ -213,10 +213,10 @@ def task_list(
         [
             _process_filterval("label", label_data),
             _process_filterval(
-                "request_time", [filter_requested_before, filter_requested_after]
+                "request_time", [filter_requested_after, filter_requested_before]
             ),
             _process_filterval(
-                "completion_time", [filter_completed_before, filter_completed_after]
+                "completion_time", [filter_completed_after, filter_completed_before]
             ),
         ]
     )

{globus_cli-3.33.0 → globus_cli-3.34.0}/src/globus_cli/commands/timer/create/transfer.py

@@ -117,7 +117,7 @@ e.g. '1h30m', '500s', '10d'
     ),
 )
 @mutex_option_group("--delete", "--delete-destination-extra")
-@LoginManager.requires_login("auth", "timer", "transfer")
+@LoginManager.requires_login("auth", "timers", "transfer")
 def transfer_command(
     login_manager: LoginManager,
     *,

{globus_cli-3.33.0 → globus_cli-3.34.0}/src/globus_cli/commands/timer/delete.py

@@ -11,7 +11,7 @@ from ._common import DELETED_TIMER_FORMAT_FIELDS
 
 @command("delete", short_help="Delete a timer.")
 @click.argument("TIMER_ID", type=click.UUID)
-@LoginManager.requires_login("timer")
+@LoginManager.requires_login("timers")
 def delete_command(login_manager: LoginManager, *, timer_id: uuid.UUID) -> None:
     """
     Delete a timer.

{globus_cli-3.33.0 → globus_cli-3.34.0}/src/globus_cli/commands/timer/list.py

@@ -6,7 +6,7 @@ from ._common import TIMER_FORMAT_FIELDS
 
 
 @command("list", short_help="List your timers.")
-@LoginManager.requires_login("timer")
+@LoginManager.requires_login("timers")
 def list_command(login_manager: LoginManager) -> None:
     """
     List your timers.

{globus_cli-3.33.0 → globus_cli-3.34.0}/src/globus_cli/commands/timer/pause.py

@@ -9,7 +9,7 @@ from globus_cli.termio import display
 
 @command("pause", short_help="Pause a timer.")
 @click.argument("TIMER_ID", type=click.UUID)
-@LoginManager.requires_login("timer")
+@LoginManager.requires_login("timers")
 def pause_command(login_manager: LoginManager, *, timer_id: uuid.UUID) -> None:
     """
     Pause a timer.

{globus_cli-3.33.0 → globus_cli-3.34.0}/src/globus_cli/commands/timer/resume.py

@@ -29,7 +29,7 @@ if t.TYPE_CHECKING:
         "if additional steps are required to successfully resume the timer."
     ),
 )
-@LoginManager.requires_login("timer")
+@LoginManager.requires_login("timers")
 def resume_command(
     login_manager: LoginManager,
     *,

{globus_cli-3.33.0 → globus_cli-3.34.0}/src/globus_cli/commands/timer/show.py

@@ -11,7 +11,7 @@ from ._common import TIMER_FORMAT_FIELDS
 
 @command("show", short_help="Display a timer.")
 @click.argument("TIMER_ID", type=click.UUID)
-@LoginManager.requires_login("timer")
+@LoginManager.requires_login("timers")
 def show_command(login_manager: LoginManager, *, timer_id: uuid.UUID) -> None:
     """
     Display information about a particular timer.

globus_cli-3.34.0/src/globus_cli/exception_handling/hooks/__init__.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import typing as t
+
+from ..registry import DeclaredHook, register_hook
+from .auth_requirements import (
+    consent_required_hook,
+    handle_internal_auth_requirements,
+    missing_login_error_hook,
+    session_hook,
+)
+from .authapi_hooks import (
+    authapi_hook,
+    authapi_unauthenticated_hook,
+    invalidrefresh_hook,
+)
+from .endpoint_types import wrong_endpoint_type_error_hook
+from .flows_hooks import (
+    flows_error_hook,
+    flows_validation_error_hook,
+    handle_flows_gare,
+)
+from .generic_hooks import (
+    globus_error_hook,
+    globusapi_hook,
+    json_error_handler,
+    null_data_error_handler,
+)
+from .search_hooks import searchapi_hook, searchapi_validationerror_hook
+from .transfer_hooks import transfer_unauthenticated_hook, transferapi_hook
+
+
+def register_all_hooks() -> None:
+    """
+    Load and register all hook functions.
+    """
+    for hook in _sort_all_hooks():
+        register_hook(hook)
+
+
+def _sort_all_hooks() -> t.Iterable[DeclaredHook[t.Any]]:
+    """
+    Iterate over all hooks in priority order.
+    """
+    # format as a list of lists for readability
+    sorted_hook_collections: list[list[DeclaredHook[t.Any]]] = [
+        # first, the generic hooks which filter out conditions
+        # running 'null data' first ensures that every other
+        # hook can assume that there is a JSON body
+        # and running json_error_handler at the start means we know (in the
+        # following hooks) that the output format is not JSON
+        [null_data_error_handler, json_error_handler],
+        # next, authn and session requirements, from most specific to most general
+        [handle_internal_auth_requirements, handle_flows_gare],
+        [session_hook, consent_required_hook],
+        # CLI internal error types, which cannot be confused with external causes
+        [missing_login_error_hook, wrong_endpoint_type_error_hook],
+        # service-specific hooks uncaptured by earlier checks
+        # each service has internal precedence ordering, but the collections could
+        # probably be put in any order
+        [authapi_unauthenticated_hook, invalidrefresh_hook, authapi_hook],
+        [transfer_unauthenticated_hook, transferapi_hook],
+        [flows_validation_error_hook, flows_error_hook],
+        [searchapi_validationerror_hook, searchapi_hook],
+        # finally, the catch-all hooks
+        [globusapi_hook, globus_error_hook],
+    ]
+
+    for hook_collection in sorted_hook_collections:
+        yield from hook_collection

globus_cli-3.34.0/src/globus_cli/exception_handling/hooks/auth_requirements.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import click
+import globus_sdk
+
+from globus_cli.login_manager import MissingLoginError
+from globus_cli.utils import CLIAuthRequirementsError
+
+from ..messages import (
+    DEFAULT_CONSENT_REAUTH_MESSAGE,
+    DEFAULT_SESSION_REAUTH_MESSAGE,
+    emit_consent_required_message,
+    emit_message_for_gare,
+    emit_session_update_message,
+)
+from ..registry import error_handler, sdk_error_handler
+
+
+@error_handler(error_class=CLIAuthRequirementsError, exit_status=4)
+def handle_internal_auth_requirements(
+    exception: CLIAuthRequirementsError,
+) -> int | None:
+    gare = exception.gare
+    if not gare:
+        msg = "Fatal Error: Unsupported internal auth requirements error!"
+        click.secho(msg, bold=True, fg="red")
+        return 255
+
+    emit_message_for_gare(gare, exception.message)
+
+    if exception.epilog:
+        click.echo("\n* * *\n")
+        click.echo(exception.epilog)
+
+    return None
+
+
+@sdk_error_handler(
+    condition=lambda err: bool(err.info.authorization_parameters), exit_status=4
+)
+def session_hook(exception: globus_sdk.GlobusAPIError) -> None:
+    """
+    Expects an exception with a valid authorization_paramaters info field.
+    """
+    message = exception.info.authorization_parameters.session_message
+    if message:
+        message = f"{DEFAULT_SESSION_REAUTH_MESSAGE}\nmessage: {message}"
+    else:
+        message = DEFAULT_SESSION_REAUTH_MESSAGE
+
+    emit_session_update_message(
+        identities=exception.info.authorization_parameters.session_required_identities,
+        domains=exception.info.authorization_parameters.session_required_single_domain,
+        policies=exception.info.authorization_parameters.session_required_policies,
+        message=message,
+    )
+    return None
+
+
+@sdk_error_handler(condition=lambda err: bool(err.info.consent_required), exit_status=4)
+def consent_required_hook(exception: globus_sdk.GlobusAPIError) -> int | None:
+    """
+    Expects an exception with a required_scopes field in its raw_json.
+    """
+    if not exception.info.consent_required.required_scopes:
+        msg = (
+            "Fatal Error: A ConsentRequired error was encountered "
+            "but the error did not contain a required_scopes field!"
+        )
+        click.secho(msg, bold=True, fg="red")
+        return 255
+
+    # specialized message for data_access errors
+    # otherwise, use more generic phrasing
+    if exception.message == "Missing required data_access consent":
+        message = (
+            "The collection you are trying to access data on requires you to "
+            "grant consent for the Globus CLI to access it."
+        )
+    else:
+        message = f"{DEFAULT_CONSENT_REAUTH_MESSAGE}\nMessage: {exception.message}"
+
+    emit_consent_required_message(
+        required_scopes=exception.info.consent_required.required_scopes, message=message
+    )
+    return None
+
+
+@error_handler(error_class=MissingLoginError, exit_status=4)
+def missing_login_error_hook(exception: MissingLoginError) -> None:
+    click.echo(
+        click.style("MissingLoginError: ", fg="yellow") + exception.message,
+        err=True,
+    )

globus_cli-3.34.0/src/globus_cli/exception_handling/hooks/authapi_hooks.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import globus_sdk
+
+from globus_cli.termio import PrintableErrorField, write_error_info
+
+from ..messages import emit_unauthorized_message
+from ..registry import sdk_error_handler
+
+
+@sdk_error_handler(
+    error_class="AuthAPIError", condition=lambda err: err.code == "UNAUTHORIZED"
+)
+def authapi_unauthenticated_hook(exception: globus_sdk.AuthAPIError) -> None:
+    emit_unauthorized_message()
+
+
+@sdk_error_handler(
+    error_class="AuthAPIError",
+    condition=lambda err: err.message == "invalid_grant",
+)
+def invalidrefresh_hook(exception: globus_sdk.AuthAPIError) -> None:
+    emit_unauthorized_message()
+
+
+@sdk_error_handler(error_class="AuthAPIError")
+def authapi_hook(exception: globus_sdk.AuthAPIError) -> None:
+    write_error_info(
+        "Auth API Error",
+        [
+            PrintableErrorField("HTTP status", exception.http_status),
+            PrintableErrorField("code", exception.code),
+            PrintableErrorField("message", exception.message, multiline=True),
+        ],
+    )

globus_cli-3.34.0/src/globus_cli/exception_handling/hooks/endpoint_types.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import click
+
+from globus_cli.endpointish import WrongEntityTypeError
+
+from ..registry import error_handler
+
+
+@error_handler(error_class=WrongEntityTypeError, exit_status=3)
+def wrong_endpoint_type_error_hook(exception: WrongEntityTypeError) -> None:
+    msg = exception.expected_message + "\n" + exception.actual_message + "\n\n"
+    click.secho(msg, fg="yellow", err=True)
+
+    should_use = exception.should_use_command()
+    if should_use:
+        click.echo(
+            "Please run the following command instead:\n\n"
+            f"    {should_use} {exception.endpoint_id}\n",
+            err=True,
+        )
+    else:
+        msg = "This operation is not supported on objects of this type."
+        click.secho(msg, fg="red", bold=True, err=True)

globus_cli-3.34.0/src/globus_cli/exception_handling/hooks/flows_hooks.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import textwrap
+import typing as t
+
+import globus_sdk
+import globus_sdk.gare
+
+from globus_cli.termio import PrintableErrorField, write_error_info
+
+from ..messages import emit_message_for_gare, pretty_json
+from ..registry import sdk_error_handler
+
+
+@sdk_error_handler(
+    error_class="FlowsAPIError",
+    condition=lambda err: globus_sdk.gare.is_gare(err.raw_json or {}),
+    exit_status=4,
+)
+def handle_flows_gare(exception: globus_sdk.FlowsAPIError) -> int | None:
+    gare = globus_sdk.gare.to_gare(exception.raw_json or {})
+    if not gare:
+        raise ValueError("Expected a GARE, but got None")
+
+    emit_message_for_gare(gare)
+    return None
+
+
+@sdk_error_handler(
+    error_class="FlowsAPIError",
+    condition=lambda err: err.code == "UNPROCESSABLE_ENTITY",
+)
+def flows_validation_error_hook(exception: globus_sdk.FlowsAPIError) -> None:
+    # we know the data must be a dict because `code` parsed (condition above)
+    error_data: dict[str, t.Any] = exception.raw_json  # type: ignore[assignment]
+
+    # try to pull the details array, empty on failure
+    details_list: list[dict[str, t.Any]] = []
+    try:
+        detail = error_data["error"]["detail"]
+        if isinstance(detail, list):
+            details_list = detail
+    except KeyError:
+        pass
+
+    # try to pull the 'message' string into a list of fields to render
+    message_fields: list[PrintableErrorField] = []
+    try:
+        message_fields = [
+            PrintableErrorField("message", error_data["error"]["message"])
+        ]
+    except KeyError:
+        pass
+
+    # if there are multiple details or we couldn't get a message
+    # then rewrite the messages to display as formatted pydantic error data
+    if len(details_list) > 1 or not message_fields:
+        num_errors = len(details_list)
+        # try to extract 'loc' and 'msg' from the details, but only
+        # update 'message_fields' if the data are present
+        try:
+            messages = [
+                f"{_jsonpath_from_pydantic_loc(data['loc'])}: {data['msg']}"
+                for data in details_list
+            ]
+        except KeyError:
+            pass
+        else:
+            message_fields = [
+                PrintableErrorField(
+                    "message", f"{num_errors} validation errors", multiline=True
+                ),
+                PrintableErrorField(
+                    "errors",
+                    "\n".join(messages),
+                    multiline=True,
+                ),
+            ]
+
+    # ultimate fallback: get the SDK's interpreted message
+    # this only applies if neither $.error.message nor $.error.detail worked
+    if not message_fields:
+        message_fields = [PrintableErrorField("message", exception.message)]
+
+    write_error_info(
+        "Flows API Error",
+        [
+            PrintableErrorField("HTTP status", exception.http_status),
+            PrintableErrorField("code", exception.code),
+            *message_fields,
+        ],
+    )
+
+
+@sdk_error_handler(error_class="FlowsAPIError")
+def flows_error_hook(exception: globus_sdk.FlowsAPIError) -> None:
+    assert exception.raw_json is not None  # Influence mypy's knowledge of `raw_json`.
+    details: list[dict[str, t.Any]] | str = exception.raw_json["error"]["detail"]
+    detail_fields: list[PrintableErrorField] = []
+
+    # if the detail is a string, return that as a single field
+    if isinstance(details, str):
+        if len(details) > 120:
+            details = textwrap.fill(details, width=80)
+        detail_fields = [PrintableErrorField("detail", details, multiline=True)]
+    # if it's a list of objects, wrap them into a multiline detail field
+    elif isinstance(details, list):
+        num_errors = len(details)
+        if all((isinstance(d, dict) and "loc" in d and "msg" in d) for d in details):
+            detail_strings = [
+                (
+                    ((data["type"] + " ") if "type" in data else "")
+                    + f"{_jsonpath_from_pydantic_loc(data['loc'])}: {data['msg']}"
+                )
+                for data in details
+            ]
+            if num_errors == 1:
+                detail_fields = [PrintableErrorField("detail", detail_strings[0])]
+            else:
+                detail_fields = [
+                    PrintableErrorField("detail", f"{num_errors} errors"),
+                    PrintableErrorField(
+                        "errors",
+                        "\n".join(detail_strings),
+                        multiline=True,
+                    ),
+                ]
+        else:
+            detail_fields = [
+                PrintableErrorField(
+                    "detail",
+                    "\n".join(pretty_json(detail, compact=True) for detail in details),
+                    multiline=True,
+                )
+            ]
+
+    fields = [
+        PrintableErrorField("HTTP status", exception.http_status),
+        PrintableErrorField("code", exception.code),
+    ]
+    if "message" in exception.raw_json["error"]:
+        fields.append(
+            PrintableErrorField("message", exception.raw_json["error"]["message"])
+        )
+    fields.extend(detail_fields)
+
+    write_error_info("Flows API Error", fields)
+
+
+_JSONPATH_SPECIAL_CHARS = "[]'\"\\."
+_JSONPATH_ESCAPE_MAP = str.maketrans(
+    {
+        "'": "\\'",
+        "\\": "\\\\",
+    }
+)
+
+
+def _jsonpath_from_pydantic_loc(loc: list[str | int]) -> str:
+    """
+    Given a 'loc' from pydantic error data, convert it into a JSON Path expression.
+
+    Takes the following steps:
+    - turns integers into integer indices
+    - turns most strings into dotted access
+    - turns strings containing special characters into single-quoted bracket access
+      with ' and \\ escaped
+    """
+    path = "$"
+    for part in loc:
+        if isinstance(part, int):
+            path += f"[{part}]"
+        else:
+            if any(c in part for c in _JSONPATH_SPECIAL_CHARS):
+                part = f"'{part.translate(_JSONPATH_ESCAPE_MAP)}'"
+                path += f"[{part}]"
+            else:
+                path += f".{part}"
+    return path

globus_cli-3.34.0/src/globus_cli/exception_handling/hooks/generic_hooks.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import json
+
+import click
+import globus_sdk
+
+from globus_cli.termio import PrintableErrorField, outformat_is_json, write_error_info
+
+from ..registry import sdk_error_handler
+
+
+@sdk_error_handler(
+    error_class="GlobusAPIError", condition=lambda err: err.raw_json is None
+)
+def null_data_error_handler(exception: globus_sdk.GlobusAPIError) -> None:
+    write_error_info(
+        "GlobusAPINullDataError",
+        [PrintableErrorField("error_type", exception.__class__.__name__)],
+    )
+
+
+@sdk_error_handler(
+    error_class="GlobusAPIError", condition=lambda err: outformat_is_json()
+)
+def json_error_handler(exception: globus_sdk.GlobusAPIError) -> None:
+    msg = json.dumps(exception.raw_json, indent=2)
+    click.secho(msg, fg="yellow", err=True)
+
+
+@sdk_error_handler()  # catch-all
+def globusapi_hook(exception: globus_sdk.GlobusAPIError) -> None:
+    write_error_info(
+        "Globus API Error",
+        [
+            PrintableErrorField("HTTP status", exception.http_status),
+            PrintableErrorField("code", exception.code),
+            PrintableErrorField("message", exception.message, multiline=True),
+        ],
+    )
+
+
+@sdk_error_handler(error_class="GlobusError")
+def globus_error_hook(exception: globus_sdk.GlobusError) -> None:
+    write_error_info(
+        "Globus Error",
+        [
+            PrintableErrorField("error_type", exception.__class__.__name__),
+            PrintableErrorField("message", str(exception), multiline=True),
+        ],
+    )