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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: globus-cli
-Version: 3.36.0
+Version: 3.37.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.3,>=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.37.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.3",
     "jmespath==1.0.1",
     "packaging>=17.0",
     "typing_extensions>=4.0;python_version<'3.11'",
@@ -69,7 +69,7 @@ test-mindeps = [
     "typing_extensions==4.0",
 ]
 typing = [
-    "mypy==1.17.1",
+    "mypy==1.18.1",
     "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.37.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.37.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.37.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.37.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.37.0}/src/globus_cli/commands/transfer.py

@@ -392,7 +392,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.37.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)

{globus_cli-3.36.0 → globus_cli-3.37.0}/src/globus_cli/termio/printers/unix_printer/unix_printer.py

@@ -8,7 +8,7 @@ import globus_sdk
 from globus_cli.types import JsonValue
 
 from ..base import Printer
-from .awscli_text import unix_display
+from ._formatter import UnixFormattingError, emit_any_value
 
 DataObject = t.Union[JsonValue, globus_sdk.GlobusHTTPResponse]
 
@@ -25,15 +25,18 @@ class UnixPrinter(Printer[DataObject]):
         res = UnixPrinter.jmespath_preprocess(data)
 
         try:
-            unix_display(res, stream=stream)  # type: ignore[no-untyped-call]
+            for line in emit_any_value(res):
+                click.echo(line, file=stream)
+
         # Attr errors indicate that we got data which cannot be unix formatted
         # likely a scalar + non-scalar in an array, though there may be other cases
         # print good error and exit(2) (Count this as UsageError!)
-        except AttributeError:
+        except UnixFormattingError as err:
             click.echo(
                 "UNIX formatting of output failed."
+                f"\n{err}"
                 "\n  "
-                "This usually means that data has a structure which cannot be "
+                "This means that data has a structure which cannot be "
                 "handled by the UNIX formatter."
                 "\n  "
                 "To avoid this error in the future, ensure that you query the "

{globus_cli-3.36.0 → globus_cli-3.37.0}/src/globus_cli/version.py

@@ -7,7 +7,7 @@ if t.TYPE_CHECKING:
 
 # single source of truth for package version,
 # see https://packaging.python.org/en/latest/single_source_version/
-__version__ = "3.36.0"
+__version__ = "3.37.0"
 
 # app name to send as part of SDK requests
 app_name = f"Globus CLI v{__version__}"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: globus-cli
-Version: 3.36.0
+Version: 3.37.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.3,>=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.37.0}/src/globus_cli.egg-info/SOURCES.txt

@@ -53,6 +53,7 @@ src/globus_cli/commands/collection/create/__init__.py
 src/globus_cli/commands/collection/create/guest.py
 src/globus_cli/commands/collection/create/mapped.py
 src/globus_cli/commands/collection/role/__init__.py
+src/globus_cli/commands/collection/role/delete.py
 src/globus_cli/commands/collection/role/list.py
 src/globus_cli/commands/collection/role/show.py
 src/globus_cli/commands/endpoint/__init__.py
@@ -270,5 +271,5 @@ src/globus_cli/termio/printers/json_printer.py
 src/globus_cli/termio/printers/record_printer.py
 src/globus_cli/termio/printers/table_printer.py
 src/globus_cli/termio/printers/unix_printer/__init__.py
-src/globus_cli/termio/printers/unix_printer/awscli_text.py
+src/globus_cli/termio/printers/unix_printer/_formatter.py
 src/globus_cli/termio/printers/unix_printer/unix_printer.py

{globus_cli-3.36.0 → globus_cli-3.37.0}/src/globus_cli.egg-info/requires.txt

@@ -1,5 +1,5 @@
-globus-sdk==3.62.0
-click<9,>=8.1.4
+globus-sdk==3.63.0
+click<8.3,>=8.1.4
 jmespath==1.0.1
 packaging>=17.0
 requests<3.0.0,>=2.32.3

globus_cli-3.36.0/src/globus_cli/termio/printers/unix_printer/awscli_text.py

@@ -1,127 +0,0 @@
-# pulled from the AWSCLI and modified by Globus
-# note that this file has also been modified by auotfixers (e.g. black, pyupgrade)
-
-# Copyright 2012-2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"). You
-# may not use this file except in compliance with the License. A copy of
-# the License is located at
-#
-#     http://aws.amazon.com/apache2.0/
-#
-# or in the "license" file accompanying this file. This file is
-# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
-# ANY KIND, either express or implied. See the License for the specific
-# language governing permissions and limitations under the License.
-
-import errno
-import sys
-
-
-def _format_text(item, stream, identifier=None, scalar_keys=None):
-    if isinstance(item, dict):
-        _format_dict(scalar_keys, item, identifier, stream)
-    elif isinstance(item, list):
-        _format_list(item, identifier, stream)
-    else:
-        # If it's not a list or a dict, we just write the scalar
-        # value out directly.
-        stream.write(str(item))
-        stream.write("\n")
-
-
-def _format_list(item, identifier, stream):
-    if not item:
-        return
-    if any(isinstance(el, dict) for el in item):
-        all_keys = _all_scalar_keys(item)
-        for element in item:
-            _format_text(
-                element, stream=stream, identifier=identifier, scalar_keys=all_keys
-            )
-    elif any(isinstance(el, list) for el in item):
-        scalar_elements, non_scalars = _partition_list(item)
-        if scalar_elements:
-            _format_scalar_list(scalar_elements, identifier, stream)
-        for non_scalar in non_scalars:
-            _format_text(non_scalar, stream=stream, identifier=identifier)
-    else:
-        _format_scalar_list(item, identifier, stream)
-
-
-def _partition_list(item):
-    scalars = []
-    non_scalars = []
-    for element in item:
-        if isinstance(element, (list, dict)):
-            non_scalars.append(element)
-        else:
-            scalars.append(element)
-    return scalars, non_scalars
-
-
-def _format_scalar_list(elements, identifier, stream):
-    if identifier is not None:
-        for item in elements:
-            stream.write(f"{identifier.upper()}\t{item}\n")
-    else:
-        # For a bare list, just print the contents.
-        stream.write("\t".join([str(item) for item in elements]))
-        stream.write("\n")
-
-
-def _format_dict(scalar_keys, item, identifier, stream):
-    scalars, non_scalars = _partition_dict(item, scalar_keys=scalar_keys)
-    if scalars:
-        if identifier is not None:
-            scalars.insert(0, identifier.upper())
-        stream.write("\t".join(scalars))
-        stream.write("\n")
-    for new_identifier, non_scalar in non_scalars:
-        _format_text(item=non_scalar, stream=stream, identifier=new_identifier)
-
-
-def _all_scalar_keys(list_of_dicts):
-    keys_seen = set()
-    for item_dict in list_of_dicts:
-        for key, value in item_dict.items():
-            if not isinstance(value, (dict, list)):
-                keys_seen.add(key)
-    return sorted(keys_seen)
-
-
-def _partition_dict(item_dict, scalar_keys):
-    # Given a dictionary, partition it into two list based on the
-    # values associated with the keys.
-    # {'foo': 'scalar', 'bar': 'scalar', 'baz': ['not, 'scalar']}
-    # scalar = [('foo', 'scalar'), ('bar', 'scalar')]
-    # non_scalar = [('baz', ['not', 'scalar'])]
-    scalar = []
-    non_scalar = []
-    if scalar_keys is None:
-        # scalar_keys can have more than just the keys in the item_dict,
-        # but if user does not provide scalar_keys, we'll grab the keys
-        # from the current item_dict
-        for key, value in sorted(item_dict.items()):
-            if isinstance(value, (dict, list)):
-                non_scalar.append((key, value))
-            else:
-                scalar.append(str(value))
-    else:
-        for key in scalar_keys:
-            scalar.append(str(item_dict.get(key, "")))
-        remaining_keys = sorted(set(item_dict.keys()) - set(scalar_keys))
-        for remaining_key in remaining_keys:
-            non_scalar.append((remaining_key, item_dict[remaining_key]))
-    return scalar, non_scalar
-
-
-def unix_display(data, stream):
-    _format_text(data, stream or sys.stdout)
-    try:
-        sys.stdout.flush()
-    except OSError as err:
-        if err.errno is errno.EPIPE:
-            pass
-        else:
-            raise