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

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

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

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

@@ -28,8 +28,8 @@ classifiers = [
 ]
 requires-python = ">=3.9"
 dependencies = [
-    "globus-sdk==3.62.0",
-    "click>=8.1.4,<9",
+    "globus-sdk==3.63.0",
+    "click>=8.1.4,<8.4",
     "jmespath==1.0.1",
     "packaging>=17.0",
     "typing_extensions>=4.0;python_version<'3.11'",
@@ -56,7 +56,7 @@ test = [
     "pytest>=7",
     "pytest-xdist<4",
     "pytest-timeout<3",
-    "click-type-test==1.1.0;python_version>='3.10'",
+    "click-type-test==1.3.0;python_version>='3.10'",
     "responses==0.25.8",
 ]
 test-mindeps = [
@@ -69,7 +69,7 @@ test-mindeps = [
     "typing_extensions==4.0",
 ]
 typing = [
-    "mypy==1.17.1",
+    "mypy==1.18.2",
     "types-jwt",
     "types-requests",
     "types-jmespath",
@@ -151,5 +151,4 @@ disallow_untyped_defs = false
 disallow_incomplete_defs = false
 module = [
     "globus_cli.services.transfer.recursive_ls",
-    "globus_cli.termio.printers.unix_printer.awscli_text",
 ]

{globus_cli-3.36.0 → globus_cli-3.38.0}/src/globus_cli/commands/collection/role/__init__.py

@@ -6,6 +6,7 @@ from globus_cli.parsing import group
     lazy_subcommands={
         "list": (".list", "list_command"),
         "show": (".show", "show_command"),
+        "delete": (".delete", "delete_command"),
     },
 )
 def role_command() -> None:

globus_cli-3.38.0/src/globus_cli/commands/collection/role/delete.py

@@ -0,0 +1,23 @@
+import uuid
+
+import click
+
+from globus_cli.login_manager import LoginManager
+from globus_cli.parsing import collection_id_arg, command
+from globus_cli.termio import display
+
+
+@command("delete")
+@collection_id_arg
+@click.argument("ROLE_ID", type=click.UUID)
+@LoginManager.requires_login("transfer")
+def delete_command(
+    login_manager: LoginManager,
+    *,
+    collection_id: uuid.UUID,
+    role_id: uuid.UUID,
+) -> None:
+    """Delete a particular role on a Collection."""
+    gcs_client = login_manager.get_gcs_client(collection_id=collection_id)
+    res = gcs_client.delete_role(role_id)
+    display(res, text_mode=display.RAW, response_key="code")

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

@@ -131,7 +131,6 @@ def delete_command(
         local_user=local_user,
         additional_fields={
             "ignore_missing": ignore_missing,
-            "skip_activation_check": skip_activation_check,
             "interpret_globs": enable_globs,
             **notify,
         },

{globus_cli-3.36.0 → globus_cli-3.38.0}/src/globus_cli/commands/group/__init__.py

@@ -19,6 +19,10 @@ from globus_cli.parsing import group
         ),
         "get-by-subscription": (".get_by_subscription", "group_get_by_subscription"),
         "update": (".update", "group_update"),
+        "set-subscription-admin-verified": (
+            ".set_subscription_admin_verified",
+            "group_set_subscription_admin_verified",
+        ),
     },
 )
 def group_command() -> None:

{globus_cli-3.36.0 → globus_cli-3.38.0}/src/globus_cli/commands/group/_common.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 import typing as t
+import uuid
 
 import click
 
+from globus_cli.constants import EXPLICIT_NULL, ExplicitNullType
 from globus_cli.termio import Field, formatters
 from globus_cli.types import AnyCommand
 
@@ -74,3 +76,22 @@ GROUP_FIELDS_W_SUBSCRIPTION = (
 
 def group_id_arg(f: C) -> C:
     return click.argument("GROUP_ID", type=click.UUID)(f)
+
+
+class GroupSubscriptionVerifiedIdType(click.ParamType):
+    name = "TEXT"
+
+    def convert(
+        self, value: str, param: click.Parameter | None, ctx: click.Context | None
+    ) -> uuid.UUID | ExplicitNullType:
+        if value.lower() == "null":
+            return EXPLICIT_NULL
+
+        try:
+            return uuid.UUID(value)
+        except ValueError:
+            msg = (
+                f"{value} is invalid. Expected either a UUID or the special value "
+                '"null"'
+            )
+            self.fail(msg, param, ctx)

globus_cli-3.38.0/src/globus_cli/commands/group/set_subscription_admin_verified.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import uuid
+
+import click
+
+from globus_cli.constants import EXPLICIT_NULL, ExplicitNullType
+from globus_cli.login_manager import LoginManager
+from globus_cli.parsing import command
+from globus_cli.termio import display
+
+from ._common import GroupSubscriptionVerifiedIdType, group_id_arg
+
+
+@command("set-subscription-admin-verified")
+@group_id_arg
+@click.argument(
+    "SUBSCRIPTION_ID",
+    type=GroupSubscriptionVerifiedIdType(),
+    metavar="[SUBSCRIPTION_ID|null]",
+)
+@LoginManager.requires_login("groups")
+def group_set_subscription_admin_verified(
+    login_manager: LoginManager,
+    *,
+    group_id: uuid.UUID,
+    subscription_id: uuid.UUID | ExplicitNullType,
+) -> None:
+    """
+    Mark a group as a subscription-verified resource.
+
+    SUBSCRIPTION_ID is the ID of the subscription to which this group shall belong,
+    or "null" to mark the group as non-verified.
+    """
+    groups_client = login_manager.get_groups_client()
+
+    admin_verified_id: str | None = (
+        None if subscription_id == EXPLICIT_NULL else str(subscription_id)
+    )
+
+    response = groups_client.set_subscription_admin_verified(
+        group_id, admin_verified_id
+    )
+
+    display(
+        response, simple_text="Group subscription verification updated successfully"
+    )

{globus_cli-3.36.0 → globus_cli-3.38.0}/src/globus_cli/commands/group/update.py

@@ -1,14 +1,16 @@
 from __future__ import annotations
 
+import typing as t
 import uuid
 
 import click
 
+from globus_cli.constants import EXPLICIT_NULL, ExplicitNullType
 from globus_cli.login_manager import LoginManager
 from globus_cli.parsing import command
 from globus_cli.termio import display
 
-from ._common import group_id_arg
+from ._common import GroupSubscriptionVerifiedIdType, group_id_arg
 
 
 @command("update")
@@ -18,6 +20,14 @@ from ._common import group_id_arg
 @click.option(
     "--terms-and-conditions", help="Terms and conditions for group membership"
 )
+@click.option(
+    "--subscription-admin-verified-id",
+    type=GroupSubscriptionVerifiedIdType(),
+    help=(
+        "The ID of the subscription to which the group belongs. Use the special value"
+        ' "null" to remove subscription verification from the group.'
+    ),
+)
 @LoginManager.requires_login("groups")
 def group_update(
     login_manager: LoginManager,
@@ -26,6 +36,7 @@ def group_update(
     name: str | None,
     description: str | None,
     terms_and_conditions: str | None,
+    subscription_admin_verified_id: uuid.UUID | None | ExplicitNullType,
 ) -> None:
     """Update an existing group."""
     groups_client = login_manager.get_groups_client()
@@ -36,7 +47,7 @@ def group_update(
     # assemble put data using existing values for any field not given
     # note that the API only allows modification of certain fields
     #   https://groups.api.globus.org/redoc#tag/groups/operation/update_group_v2_groups__group_id__put
-    data = {}
+    data: dict[str, t.Any] = {}
     for attrname, argval in (
         ("name", name),
         ("description", description),
@@ -47,6 +58,19 @@ def group_update(
         else:
             data[attrname] = group[attrname]
 
+    if subscription_admin_verified_id == EXPLICIT_NULL:
+        data["subscription_admin_verified_id"] = None
+    elif (
+        subscription_admin_verified_id == group["subscription_admin_verified_id"]
+        or subscription_admin_verified_id is None
+    ):
+        data["subscription_admin_verified_id"] = group["subscription_admin_verified_id"]
+    else:
+        raise click.UsageError(
+            "To set the `subscription_admin_verified_id` to a new, non-null value, use "
+            "`globus group set-subscription-admin-verified`"
+        )
+
     response = groups_client.update_group(group_id, data)
 
     display(response, simple_text="Group updated successfully")

{globus_cli-3.36.0 → globus_cli-3.38.0}/src/globus_cli/commands/rm.py

@@ -88,7 +88,6 @@ def rm_command(
         local_user=local_user,
         additional_fields={
             "ignore_missing": ignore_missing,
-            "skip_activation_check": skip_activation_check,
             "interpret_globs": enable_globs,
             **notify,
         },

{globus_cli-3.36.0 → globus_cli-3.38.0}/src/globus_cli/commands/timer/create/transfer.py

@@ -16,6 +16,7 @@ from globus_cli.parsing import (
     command,
     encrypt_data_option,
     fail_on_quota_errors_option,
+    filter_rule_options,
     mutex_option_group,
     preserve_timestamp_option,
     skip_source_errors_option,
@@ -54,7 +55,14 @@ e.g. '1h30m', '500s', '10d'
 """
 
 
-@command("transfer", short_help="Create a recurring transfer timer.")
+@command(
+    "transfer",
+    opts_to_combine={  # see 'filter_rule_options' for why this is needed
+        "include": "filter_rules",
+        "exclude": "filter_rules",
+    },
+    short_help="Create a recurring transfer timer.",
+)
 @click.argument(
     "source", metavar="SOURCE_ENDPOINT_ID[:SOURCE_PATH]", type=ENDPOINT_PLUS_OPTPATH
 )
@@ -70,6 +78,7 @@ e.g. '1h30m', '500s', '10d'
 @skip_source_errors_option
 @fail_on_quota_errors_option
 @task_notify_option
+@filter_rule_options
 @click.option(
     "--start",
     type=click.DateTime(formats=DATETIME_FORMATS),
@@ -139,6 +148,7 @@ def transfer_command(
     preserve_timestamp: bool,
     skip_source_errors: bool,
     fail_on_quota_errors: bool,
+    filter_rules: list[tuple[t.Literal["include", "exclude"], str]],
     notify: dict[str, bool],
 ) -> None:
     """
@@ -305,6 +315,10 @@ def transfer_command(
         **notify,  # type: ignore[arg-type]
     )
 
+    for rule in filter_rules:
+        method, name = rule
+        transfer_data.add_filter_rule(method=method, name=name, type="file")
+
     if batch:
         add_batch_to_transfer_data(
             cmd_source_path, cmd_dest_path, None, transfer_data, batch

{globus_cli-3.36.0 → globus_cli-3.38.0}/src/globus_cli/commands/transfer.py

@@ -12,6 +12,7 @@ from globus_cli.parsing import (
     command,
     encrypt_data_option,
     fail_on_quota_errors_option,
+    filter_rule_options,
     mutex_option_group,
     preserve_timestamp_option,
     skip_source_errors_option,
@@ -136,6 +137,7 @@ fi
 @encrypt_data_option(aliases=("--encrypt",))
 @skip_source_errors_option
 @fail_on_quota_errors_option
+@filter_rule_options
 @click.option(
     "--delete",
     is_flag=True,
@@ -170,32 +172,6 @@ fi
     show_default=True,
     help="Specify an algorithm for --external-checksum or --verify-checksum",
 )
-@click.option(
-    "--include",
-    multiple=True,
-    show_default=True,
-    expose_value=False,  # this is combined into the filter_rules parameter
-    help=(
-        "Include files found with names that match the given pattern in "
-        'recursive transfers. Pattern may include "*", "?", or "[]" for Unix-style '
-        "globbing. This option can be given multiple times along with "
-        "--exclude to control which files are transferred, with earlier "
-        "options having priority."
-    ),
-)
-@click.option(
-    "--exclude",
-    multiple=True,
-    show_default=True,
-    expose_value=False,  # this is combined into the filter_rules parameter
-    help=(
-        "Exclude files found with names that match the given pattern in "
-        'recursive transfers. Pattern may include "*", "?", or "[]" for Unix-style '
-        "globbing. This option can be given multiple times along with "
-        "--include to control which files are transferred, with earlier "
-        "options having priority."
-    ),
-)
 @click.option(
     "--source-local-user",
     help=(
@@ -392,7 +368,6 @@ def transfer_command(
         deadline=deadline,
         skip_source_errors=skip_source_errors,
         fail_on_quota_errors=fail_on_quota_errors,
-        skip_activation_check=skip_activation_check,
         delete_destination_extra=(delete or delete_destination_extra),
         source_local_user=source_local_user,
         destination_local_user=destination_local_user,

{globus_cli-3.36.0 → globus_cli-3.38.0}/src/globus_cli/login_manager/scopes.py

@@ -94,7 +94,6 @@ class _CLIScopeRequirements(t.Dict[ServiceNameLiteral, _ServiceRequirement]):
             "scopes": [
                 FlowsScopes.manage_flows,
                 FlowsScopes.view_flows,
-                FlowsScopes.run,
                 FlowsScopes.run_status,
                 FlowsScopes.run_manage,
             ],

{globus_cli-3.36.0 → globus_cli-3.38.0}/src/globus_cli/parsing/__init__.py

@@ -38,6 +38,7 @@ from .shared_options.id_args import (
 from .shared_options.transfer_task_options import (
     encrypt_data_option,
     fail_on_quota_errors_option,
+    filter_rule_options,
     preserve_timestamp_option,
     skip_source_errors_option,
     sync_level_option,
@@ -84,6 +85,7 @@ __all__ = [
     "sync_level_option",
     "task_notify_option",
     "fail_on_quota_errors_option",
+    "filter_rule_options",
     "encrypt_data_option",
     "preserve_timestamp_option",
     "skip_source_errors_option",

{globus_cli-3.36.0 → globus_cli-3.38.0}/src/globus_cli/parsing/shared_options/transfer_task_options.py

@@ -125,3 +125,46 @@ def encrypt_data_option(*, aliases: tuple[str, ...] = ()) -> t.Callable[[C], C]:
         )(f)
 
     return decorator
+
+
+def filter_rule_options(f: C) -> C:
+    """
+    Use of this decorator must be used with
+
+        opts_to_combine={
+            "include": "filter_rules",
+            "exclude": "filter_rules",
+        }
+
+    in order to produce correct `filter_rules` list.
+
+    The order of `--include` and `--exclude` determines behavior, and we have to
+    modify parsing to get that ordering information.
+    """
+    f = click.option(
+        "--include",
+        multiple=True,
+        show_default=True,
+        expose_value=False,  # this is combined into the filter_rules parameter
+        help=(
+            "Include files found with names that match the given pattern in "
+            'recursive transfers. Pattern may include "*", "?", or "[]" for Unix-style '
+            "globbing. This option can be given multiple times along with "
+            "--exclude to control which files are transferred, with earlier "
+            "options having priority."
+        ),
+    )(f)
+    f = click.option(
+        "--exclude",
+        multiple=True,
+        show_default=True,
+        expose_value=False,  # this is combined into the filter_rules parameter
+        help=(
+            "Exclude files found with names that match the given pattern in "
+            'recursive transfers. Pattern may include "*", "?", or "[]" for Unix-style '
+            "globbing. This option can be given multiple times along with "
+            "--include to control which files are transferred, with earlier "
+            "options having priority."
+        ),
+    )(f)
+    return f

globus_cli-3.38.0/src/globus_cli/termio/printers/unix_printer/_formatter.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+import sys
+import typing as t
+from itertools import chain
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
+
+Scalar: TypeAlias = "str | int | float | bool | None"
+NonScalar: TypeAlias = "list[Scalar | NonScalar] | dict[str, Scalar | NonScalar]"
+
+
+class UnixFormattingError(ValueError):
+    """Class of errors indicating that the data could not be formatted."""
+
+
+def emit_any_value(item: Scalar | NonScalar) -> t.Iterator[str]:
+    """
+    Emission of values is defined as yielding back each line of output.
+
+    Lists and dicts are handled specially. Any scalar value is just passed to Python
+    ``str()``. Note that this means that null becomes "None" in our output.
+    """
+    if isinstance(item, list):
+        yield from emit_list(item)
+    elif isinstance(item, dict):
+        yield from emit_dict(item)
+    else:
+        yield str(item)
+
+
+def emit_list(
+    elements: list[Scalar | NonScalar],
+    identifier: str | None = None,
+) -> t.Iterator[str]:
+    """
+    Given a list, and optionally some identifier used to tag the output, emit lines of
+    output.
+
+    Supports:
+        list[dict] , list[scalar] , and list[list | scalar]
+
+    If the input mixes dicts and non-dict values, this function will raise a ValueError.
+    """
+    # empty lists disappear in the output
+    if not elements:
+        return
+
+    # across these branches, mypy does not correctly narrow the type of `elements`
+    # so we need to type-ignore the argument type
+    if all(isinstance(item, dict) for item in elements):
+        yield from emit_list_of_dicts(
+            elements,  # type: ignore[arg-type]
+            identifier=identifier,
+        )
+    elif any(isinstance(item, dict) for item in elements):
+        raise UnixFormattingError(
+            "Formatter cannot handle arrays which mix JSON objects "
+            "with other datatypes."
+        )
+
+    elif any(isinstance(item, list) for item in elements):
+        yield from emit_list_containing_lists(
+            elements,  # type: ignore[arg-type]
+            identifier=identifier,
+        )
+    else:
+        yield from emit_scalar_list(
+            elements,  # type: ignore[arg-type]
+            identifier=identifier,
+        )
+
+
+def emit_scalar_list(
+    elements: list[Scalar], identifier: str | None = None
+) -> t.Iterator[str]:
+    """
+    Emit a list of scalars, with or without an identifier.
+
+    Given an identifier, each element is placed on a separate line of output:
+
+        >>> emit_scalar_list([1, 2], identifier="FOO")
+        FOO\t1
+        FOO\t2
+
+    Without an identifier, all elements are placed on the same line:
+
+        >>> emit_scalar_list([1, 2], identifier="FOO")
+        1\t2
+    """
+    if identifier is not None:
+        for item in elements:
+            yield f"{identifier}\t{item}"
+    else:
+        yield "\t".join(str(item) for item in elements)
+
+
+def emit_list_containing_lists(
+    elements: list[Scalar | list[Scalar | NonScalar]],
+    identifier: str | None = None,
+) -> t.Iterator[str]:
+    """
+    Emit a list which contains nested lists, potentially mixed with scalars.
+    First, the scalars are split off and emitted, then all of the nested lists are
+    emitted in order of appearance.
+    """
+    scalars: list[Scalar] = []
+    nested: list[list[Scalar | NonScalar]] = []
+    for item in elements:
+        if isinstance(item, list):
+            nested.append(item)
+        else:
+            scalars.append(item)
+
+    if scalars:
+        yield from emit_scalar_list(scalars)
+    for nested_list in nested:
+        yield from emit_list(nested_list, identifier=identifier)
+
+
+def emit_list_of_dicts(
+    elements: list[dict[str, Scalar | NonScalar]], identifier: str | None = None
+) -> t.Iterator[str]:
+    keys = extract_scalar_keys(elements)
+    for item in elements:
+        yield from emit_dict(item, identifier=identifier, scalar_keys=keys)
+
+
+def emit_dict(
+    item: dict[str, Scalar | NonScalar],
+    identifier: str | None = None,
+    scalar_keys: list[str] | None = None,
+) -> t.Iterator[str]:
+    if scalar_keys is None:
+        scalar_keys = extract_scalar_keys(item)
+    scalars, non_scalars = partition_dict(item, scalar_keys)
+
+    if scalars:
+        if identifier is not None:
+            yield identifier
+        yield "\t".join(str(s) for s in scalars)
+
+    for subkey, value in non_scalars:
+        if isinstance(value, list):
+            yield from emit_list(value, identifier=subkey.upper())
+        else:
+            yield from emit_dict(value, identifier=subkey.upper())
+
+
+def partition_dict(
+    item: dict[str, Scalar | NonScalar], scalar_keys: list[str]
+) -> tuple[list[Scalar], list[tuple[str, NonScalar]]]:
+    """
+    Given a dict and a collection of keys for its scalar parts, split it into two lists
+    representing the scalar and non-scalar parts.
+    The non-scalar parts retain their keys.
+
+    This method assumes that the 'scalar_keys' provided are correct to the dict in
+    question.
+    """
+    scalars: list[Scalar] = []
+    non_scalars: list[tuple[str, NonScalar]] = []
+
+    non_scalar_keys = sorted(set(item.keys()) - set(scalar_keys))
+
+    for key in scalar_keys:
+        value = item.get(key)
+
+        # we are not guaranteed that the scalar keys really map to scalars
+        # but if they don't, formatting will break, so error early
+        if isinstance(value, (list, dict)):
+            raise UnixFormattingError(
+                "Error during UNIX formatting of response data. "
+                "Lists where key-value mappings are not uniformly scalar or non-scalar "
+                "are not supported."
+            )
+
+        scalars.append(str(value))
+
+    for key in non_scalar_keys:
+        value = item[key]
+
+        # converse of the above: we are not "guaranteed" that the non-scalar keys
+        # do not map to scalars on a heterogeneous list[dict] structure
+        #
+        # in practice, this is not reachable because `extract_scalar_keys()` prefers
+        # to categorize data as scalar
+        if not isinstance(value, (list, dict)):
+            raise UnixFormattingError(
+                "Error during UNIX formatting of response data. "
+                "Lists where key-value mappings are not uniformly scalar or non-scalar "
+                "are not supported."
+            )
+
+        non_scalars.append((key, value))
+
+    return scalars, non_scalars
+
+
+def extract_scalar_keys(
+    element_or_elements: (
+        dict[str, Scalar | NonScalar] | list[dict[str, Scalar | NonScalar]]
+    ),
+) -> list[str]:
+    if isinstance(element_or_elements, dict):
+        elements: list[dict[str, Scalar | NonScalar]] = [element_or_elements]
+    else:
+        elements = element_or_elements
+
+    seen: set[str] = set()
+    for key, value in chain(*(item.items() for item in elements)):
+        if key in seen:
+            continue
+        if isinstance(value, (dict, list)):
+            continue
+        seen.add(key)
+    return sorted(seen)