globus-cli 3.42.0__tar.gz → 3.43.0__tar.gz

{globus_cli-3.42.0 → globus_cli-3.43.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: globus-cli
-Version: 3.42.0
+Version: 3.43.0
 Summary: Globus CLI
 Keywords: globus,cli,command line
 Author-email: Stephen Rosen <sirosen@globus.org>
@@ -17,13 +17,14 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 License-File: LICENSE
-Requires-Dist: globus-sdk==4.8.0
+Requires-Dist: globus-sdk==4.9.0
 Requires-Dist: click>=8.4,<8.5
 Requires-Dist: jmespath==1.1.0
 Requires-Dist: packaging>=17.0
 Requires-Dist: typing_extensions>=4.0;python_version<'3.11'
-Requires-Dist: requests>=2.32.3,<3.0.0
+Requires-Dist: requests>=2.34.2,<3.0.0
 Project-URL: homepage, https://github.com/globus/globus-cli
+Import-Name: globus_cli
 
 Globus CLI
 ==========

{globus_cli-3.42.0 → globus_cli-3.43.0}/changelog.adoc

@@ -2,6 +2,25 @@
 
 // scriv-insert-here
 
+== 3.43.0 (2026-08-12)
+
+Bugfixes:
+
+* Fixed a bug in which terminal device (TTY) detection ran even when
+  `GLOBUS_CLI_FOLD_TABLES=1` is set.
+  Setting the variable to true now forces use of folded tables.
+  Non-TTY output devices will be detected as having a fixed width of 80
+  characters.
+
+* Fixed `globus get-identities` to lowercase usernames and IDs before
+  comparisons for normal text output.
+
+Enhancements:
+
+* Folded table output will now have bolded headers in interactive terminals.
+
+* Add `globus flows web-input` subcommands to interact with Web Inputs.
+
 == 3.42.0 (2026-06-10)
 
 Bugfixes:

{globus_cli-3.42.0 → globus_cli-3.43.0}/pyproject.toml

@@ -28,7 +28,7 @@ classifiers = [
 ]
 requires-python = ">=3.10"
 dependencies = [
-    "globus-sdk==4.8.0",
+    "globus-sdk==4.9.0",
     # NOTE: `click` does not use semver; minor releases are expected to contain
     #       minor breaking changes
     "click>=8.4,<8.5",
@@ -37,7 +37,7 @@ dependencies = [
     "typing_extensions>=4.0;python_version<'3.11'",
     # these are dependencies of the SDK, but they are used directly in the CLI
     # declare them here in case the underlying lib ever changes
-    "requests>=2.32.3,<3.0.0",
+    "requests>=2.34.2,<3.0.0",
 ]
 dynamic = ["version"]
 
@@ -64,20 +64,20 @@ test = [
 test-mindeps = [
     {include-group = "test"},
     "click==8.4.0",
-    "requests==2.32.4",
+    "requests==2.34.2",
     "pyjwt==2.0.0",
     "cryptography==3.3.1",
     "packaging==17.0",
     "typing_extensions==4.0",
 ]
 typing = [
-    "mypy==1.19.1",
+    "mypy==2.1.0",
     "types-jwt",
     "types-requests",
     "types-jmespath",
 ]
 check-project-metadata = [
-    "mddj==0.4.2",
+    "mddj==0.6.0",
     {include-group = "yaml"},
     "build",
     "twine",

{globus_cli-3.42.0 → globus_cli-3.43.0}/src/globus_cli/commands/flows/__init__.py

@@ -15,6 +15,8 @@ from globus_cli.parsing import group
         "run": (".run", "run_command"),
         # "registered-api" is a subgroup of commands.
         "registered-api": (".registered_api", "registered_api_command"),
+        # "web-input" is a subgroup of commands.
+        "web-input": (".web_input", "web_input_command"),
     },
 )
 def flows_command() -> None:

{globus_cli-3.42.0 → globus_cli-3.43.0}/src/globus_cli/commands/flows/_common.py

@@ -131,13 +131,21 @@ class SubscriptionIdType(
     name = "SUBSCRIPTION_ID"
 
     def __init__(self, *, omittable: bool = False) -> None:
-        self._omittable = omittable
+        self._omittable: bool = omittable
 
     def convert(
-        self, value: t.Any, param: click.Parameter | None, ctx: click.Context | None
+        self,
+        value: t.Any | globus_sdk.MissingType,
+        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 is globus_sdk.MISSING:
+            if self._omittable:
+                return globus_sdk.MISSING
+            else:
+                raise NotImplementedError(
+                    "Cannot pass MISSING to non-omittable SubscriptionidType."
+                )
 
         if value.upper() == "DEFAULT":
             return "DEFAULT"

{globus_cli-3.42.0 → globus_cli-3.43.0}/src/globus_cli/commands/flows/_fields.py

@@ -3,6 +3,10 @@ import typing as t
 import globus_sdk
 
 from globus_cli.termio import Field, formatters
+from globus_cli.termio.formatters import (
+    ArrayFormatter,
+    FieldFormatter,
+)
 from globus_cli.termio.formatters.auth import PrincipalURNFormatter
 
 
@@ -165,3 +169,115 @@ def registered_api_format_fields(
         Field("Destination Method", "target.destination.method"),
         Field("Destination URL", "target.destination.url"),
     ]
+
+
+class WebInputPrincipalFormatter(PrincipalURNFormatter):
+    """A principal formatter which pre-registers all principals for a web input."""
+
+    def __init__(
+        self, auth_client: globus_sdk.AuthClient, web_input: dict[str, t.Any]
+    ) -> None:
+        super().__init__(auth_client)
+        self.add_items(web_input.get("creator_urn"))
+        roles = web_input.get("roles", {})
+        self.add_items(*roles.get("viewer_urns", ()))
+        self.add_items(*roles.get("respondent_urns", ()))
+
+
+class IdentifiedResourceFormatter(FieldFormatter[str]):
+    def parse(self, value: t.Any) -> str:
+        if not isinstance(value, list) or len(value) != 2:
+            raise ValueError("cannot format parenthetical from data of wrong shape")
+        name, resource_id = value[0], value[1]
+        if not isinstance(resource_id, str):
+            raise ValueError("cannot format parenthetical non-str id")
+        if isinstance(name, str):
+            # If the name can be parsed, render it alongside the resource id
+            return f"{name} ({resource_id})"
+        # If the name can't be parsed, just render the resource id
+        return resource_id
+
+    def render(self, value: str) -> str:
+        return value
+
+
+class _OptionFormatter(FieldFormatter[tuple[t.Any, t.Any]]):
+    def parse(self, value: t.Any) -> tuple[t.Any, t.Any]:
+        if not isinstance(value, dict):
+            raise ValueError("non-dict field value")
+        elif "option_id" not in value or "label" not in value:
+            raise ValueError("missing key 'option_id' and/or 'label'")
+        return value["option_id"], value["label"]
+
+    def render(self, value: tuple[t.Any, t.Any]) -> str:
+        option_id, label = value
+        return f"*  {option_id}  {label}"
+
+
+class _WebInputContextRowsFormatter(FieldFormatter[t.List[t.Tuple[str, str]]]):
+    """Renders a list of {field, value} rows as an aligned 'field: value' block."""
+
+    def parse(self, value: t.Any) -> list[tuple[str, str]]:
+        if not isinstance(value, list):
+            raise ValueError("non list context rows value")
+        rows = []
+        for item in value:
+            if not isinstance(item, dict) or "field" not in item or "value" not in item:
+                raise ValueError("missing key 'field' and/or 'value'")
+            rows.append((item["field"], item["value"]))
+        return rows
+
+    def render(self, value: list[tuple[str, str]]) -> str:
+        width = max(len(field) for field, _ in value) + 2
+        return "\n".join(f"{field}:".ljust(width) + str(val) for field, val in value)
+
+
+def web_input_format_fields(
+    auth_client: globus_sdk.AuthClient,
+    web_input: dict[str, t.Any],
+) -> list[Field]:
+    """
+    The standard list of fields to render for a web input resource.
+
+    :param auth_client: An AuthClient, used to resolve principal URNs.
+    :param web_input: The web input resource, used to pre-register principals.
+    """
+    principal = WebInputPrincipalFormatter(auth_client, web_input)
+    csv_principal_list = formatters.ArrayFormatter(
+        element_formatter=principal,
+        delimiter=", ",
+    )
+    csv_list = formatters.ArrayFormatter(delimiter=", ")
+    flow_run_formatter = IdentifiedResourceFormatter()
+
+    fields = [
+        Field("Web Input ID", "id"),
+        Field("Status", "status"),
+        Field("Title", "context.title"),
+        Field("Your Roles", "user_roles", formatter=csv_list),
+        Field("Flow", "[flow.title, flow.id]", formatter=flow_run_formatter),
+        Field("Run", "[run.label, run.id]", formatter=flow_run_formatter),
+        Field("Creator", "creator_urn", formatter=principal),
+        Field("Viewers", "roles.viewer_urns", formatter=csv_principal_list),
+        Field("Respondents", "roles.respondent_urns", formatter=csv_principal_list),
+        Field("Created At", "created_timestamp", formatter=formatters.Date),
+        Field("Closed At", "closed_timestamp", formatter=formatters.Date),
+    ]
+
+    if web_input.get("context", {}).get("presentation_style") == "table":
+        fields += [
+            Field(
+                "Context",
+                "context.rows",
+                section=True,
+                formatter=_WebInputContextRowsFormatter(),
+            )
+        ]
+    else:
+        fields += [Field("Context", "context.text", section=True)]
+
+    if web_input.get("options"):
+        formatter = ArrayFormatter(delimiter="\n", element_formatter=_OptionFormatter())
+        fields += [Field("Options", "options", section=True, formatter=formatter)]
+
+    return fields

globus_cli-3.43.0/src/globus_cli/commands/flows/web_input/__init__.py

@@ -0,0 +1,13 @@
+from globus_cli.parsing import group
+
+
+@group(
+    "web-input",
+    lazy_subcommands={
+        "show": (".show", "show_command"),
+        "list": (".list", "list_command"),
+        "respond": (".respond", "respond_command"),
+    },
+)
+def web_input_command() -> None:
+    """Interact with web inputs in the Globus Flows service."""

globus_cli-3.43.0/src/globus_cli/commands/flows/web_input/list.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import typing as t
+import uuid
+
+import click
+import globus_sdk
+from globus_sdk.paging import Paginator
+
+from globus_cli.login_manager import LoginManager
+from globus_cli.parsing import ColonDelimitedChoiceTuple, command
+from globus_cli.termio import Field, display
+from globus_cli.utils import PagingWrapper
+
+ROLE_TYPES = ("viewer", "respondent")
+STATE_TYPES = ("open", "closed")
+ORDER_BY_FIELDS = ("created_timestamp", "edited_timestamp", "closed_timestamp")
+
+
+@command("list")
+@click.option(
+    "--filter-role",
+    "filter_roles",
+    type=click.Choice(ROLE_TYPES),
+    help="Filter results by the caller's role on the web input",
+    multiple=True,
+)
+@click.option(
+    "--filter-state",
+    "filter_states",
+    type=click.Choice(STATE_TYPES),
+    help="Filter results by the web input's state",
+    multiple=True,
+)
+@click.option(
+    "--filter-flow-id",
+    "filter_flow_ids",
+    help=(
+        "Filter results to web inputs with a particular flow ID or flow IDs. "
+        "This option may be specified multiple times to filter by multiple "
+        "flow IDs."
+    ),
+    multiple=True,
+    type=click.UUID,
+)
+@click.option(
+    "--filter-run-id",
+    "filter_run_ids",
+    help=(
+        "Filter results to web inputs with a particular run ID or run IDs. "
+        "This option may be specified multiple times to filter by multiple "
+        "run IDs."
+    ),
+    multiple=True,
+    type=click.UUID,
+)
+@click.option(
+    "--orderby",
+    default=("created_timestamp:DESC",),
+    show_default=True,
+    type=ColonDelimitedChoiceTuple(
+        choices=tuple(
+            f"{field}:{order}" for field in ORDER_BY_FIELDS for order in ("ASC", "DESC")
+        ),
+        case_sensitive=False,
+    ),
+    multiple=True,
+    metavar=f"[{'|'.join(ORDER_BY_FIELDS)}]:[ASC|DESC]",
+    help="""
+        Sort results by the given field and ordering.
+        ASC for ascending, DESC for descending.
+
+        This option can be specified multiple times to sort by multiple fields.
+    """,
+)
+@click.option(
+    "--limit",
+    default=25,
+    show_default=True,
+    metavar="N",
+    type=click.IntRange(1),
+    help="The maximum number of results to return.",
+)
+@LoginManager.requires_login("flows")
+def list_command(
+    login_manager: LoginManager,
+    *,
+    filter_roles: tuple[t.Literal["viewer", "respondent"], ...],
+    filter_states: tuple[t.Literal["open", "closed"], ...],
+    filter_flow_ids: tuple[uuid.UUID, ...],
+    filter_run_ids: tuple[uuid.UUID, ...],
+    orderby: tuple[
+        tuple[
+            t.Literal["created_timestamp", "edited_timestamp", "closed_timestamp"],
+            t.Literal["ASC", "DESC"],
+        ],
+        ...,
+    ],
+    limit: int,
+) -> None:
+    """
+    List web inputs accessible to the current user.
+    """
+    flows_client = login_manager.get_flows_client()
+
+    paginator = Paginator.wrap(flows_client.list_web_inputs)
+    web_input_iterator = PagingWrapper(
+        paginator(
+            filter_roles=filter_roles or globus_sdk.MISSING,
+            filter_states=filter_states or globus_sdk.MISSING,
+            filter_flow_ids=filter_flow_ids or globus_sdk.MISSING,
+            filter_run_ids=filter_run_ids or globus_sdk.MISSING,
+            orderby=",".join(f"{field} {order}" for field, order in orderby),
+        ).items(),
+        json_conversion_key="web_input_summaries",
+        limit=limit,
+    )
+
+    fields = [
+        Field("Web Input ID", "id"),
+        Field("Status", "status"),
+        Field("Input Type", "input_type"),
+        Field("Title", "title"),
+        Field("Flow Title", "flow.title"),
+        Field("Run Label", "run.label"),
+    ]
+
+    display(
+        web_input_iterator,
+        fields=fields,
+        json_converter=web_input_iterator.json_converter,
+    )

globus_cli-3.43.0/src/globus_cli/commands/flows/web_input/respond.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import uuid
+
+import click
+
+from globus_cli.login_manager import LoginManager
+from globus_cli.parsing import command, web_input_id_arg
+from globus_cli.termio import Field, display
+
+
+@command("respond")
+@web_input_id_arg
+@click.argument("option_id", metavar="OPTION_ID", type=click.UUID, required=True)
+@LoginManager.requires_login("flows")
+def respond_command(
+    login_manager: LoginManager,
+    *,
+    web_input_id: uuid.UUID,
+    option_id: uuid.UUID,
+) -> None:
+    """
+    Respond to a web input.
+
+    For "selection" type web inputs, OPTION_ID is the ID of one of the web input's
+    available options.
+    """
+
+    flows_client = login_manager.get_flows_client()
+    response = flows_client.respond_to_web_input(web_input_id, value=option_id)
+
+    display(
+        response,
+        text_mode=display.RECORD,
+        fields=[Field("Status", "status")],
+    )

globus_cli-3.43.0/src/globus_cli/commands/flows/web_input/show.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import uuid
+
+from globus_cli.commands.flows._fields import web_input_format_fields
+from globus_cli.login_manager import LoginManager
+from globus_cli.parsing import command, web_input_id_arg
+from globus_cli.termio import display
+
+
+@command("show")
+@web_input_id_arg
+@LoginManager.requires_login("auth", "flows")
+def show_command(login_manager: LoginManager, *, web_input_id: uuid.UUID) -> None:
+    """
+    Show a web input.
+    """
+    flows_client = login_manager.get_flows_client()
+    auth_client = login_manager.get_auth_client()
+
+    response = flows_client.get_web_input(web_input_id)
+    fields = web_input_format_fields(auth_client, response.data)
+
+    display(response, fields=fields, text_mode=display.RECORD)

{globus_cli-3.42.0 → globus_cli-3.43.0}/src/globus_cli/commands/get_identities.py

@@ -80,15 +80,25 @@ def get_identities_command(
         Non-verbose text output is customized.
         """
 
-        def resolve_identity(value: dict[str, t.Any]) -> str:
+        def resolve_identity(value: str) -> str:
             """
-            Helper to deal with variable inputs and uncertain response order.
+            Given an input, resolve it to an output:
+
+            - IDs resolve to usernames
+            - Usernames resolve to IDs
+            - Missing values resolve to 'NO_SUCH_IDENTITY'
+            - Comparisons are all done lowercased
             """
+            value = value.lower()
             for identity in identities:
-                if identity["id"] == value:
-                    return t.cast(str, identity["username"])
-                if identity["username"] == value:
-                    return t.cast(str, identity["id"])
+                if identity["id"].lower() == value:
+                    username = identity["username"]
+                    if isinstance(username, str):
+                        return username
+                if identity["username"].lower() == value:
+                    identity_id = identity["id"]
+                    if isinstance(identity_id, str):
+                        return identity_id
             return "NO_SUCH_IDENTITY"
 
         # standard output is one resolved identity per line in the same order

{globus_cli-3.42.0 → globus_cli-3.43.0}/src/globus_cli/parsing/__init__.py

@@ -40,6 +40,7 @@ from .shared_options.id_args import (
     endpoint_id_arg,
     flow_id_arg,
     run_id_arg,
+    web_input_id_arg,
 )
 from .shared_options.transfer_task_options import (
     encrypt_data_option,
@@ -86,6 +87,7 @@ __all__ = [
     "endpoint_id_arg",
     "flow_id_arg",
     "run_id_arg",
+    "web_input_id_arg",
     "flow_input_document_option",
     "task_submission_options",
     "delete_and_rm_options",

{globus_cli-3.42.0 → globus_cli-3.43.0}/src/globus_cli/parsing/param_types/delimited.py

@@ -28,12 +28,18 @@ class CommaDelimitedList(click.ParamType[list[str] | globus_sdk.MissingType]):
         return "TEXT,TEXT,..."
 
     def convert(
-        self, value: t.Any, param: click.Parameter | None, ctx: click.Context | None
+        self,
+        value: t.Any | globus_sdk.MissingType,
+        param: click.Parameter | None,
+        ctx: click.Context | None,
     ) -> list[str] | globus_sdk.MissingType:
-        if self._omittable and value is globus_sdk.MISSING:
-            return globus_sdk.MISSING
-
-        value = super().convert(value, param, ctx)
+        if value is globus_sdk.MISSING:
+            if self._omittable:
+                return globus_sdk.MISSING
+            else:
+                raise NotImplementedError(
+                    "Cannot pass MISSING to non-omittable CommaDelimitedList."
+                )
 
         # if `--foo` is a comma delimited list and someone passes
         # `--foo ""`, take that as `foo=[]` rather than foo=[""]

{globus_cli-3.42.0 → globus_cli-3.43.0}/src/globus_cli/parsing/param_types/omittable.py

@@ -12,7 +12,10 @@ class OmittableInt(click.ParamType[int | globus_sdk.MissingType]):
     name = "integer"
 
     def convert(
-        self, value: t.Any, param: click.Parameter | None, ctx: click.Context | None
+        self,
+        value: t.Any | globus_sdk.MissingType,
+        param: click.Parameter | None,
+        ctx: click.Context | None,
     ) -> int | globus_sdk.MissingType:
         if value is globus_sdk.MISSING:
             return globus_sdk.MISSING
@@ -26,7 +29,10 @@ class OmittableString(click.ParamType[str | globus_sdk.MissingType]):
     name = "text"
 
     def convert(
-        self, value: t.Any, param: click.Parameter | None, ctx: click.Context | None
+        self,
+        value: t.Any | globus_sdk.MissingType,
+        param: click.Parameter | None,
+        ctx: click.Context | None,
     ) -> str | globus_sdk.MissingType:
         if value is globus_sdk.MISSING:
             return globus_sdk.MISSING
@@ -40,7 +46,10 @@ class OmittableUUID(click.ParamType[uuid.UUID | globus_sdk.MissingType]):
     name = "uuid"
 
     def convert(
-        self, value: t.Any, param: click.Parameter | None, ctx: click.Context | None
+        self,
+        value: t.Any | globus_sdk.MissingType,
+        param: click.Parameter | None,
+        ctx: click.Context | None,
     ) -> uuid.UUID | globus_sdk.MissingType:
         if value is globus_sdk.MISSING:
             return globus_sdk.MISSING
@@ -65,7 +74,10 @@ class OmittableChoice(click.ParamType[str | globus_sdk.MissingType]):
         return self._inner_choice.get_missing_message(param, ctx)
 
     def convert(
-        self, value: t.Any, param: click.Parameter | None, ctx: click.Context | None
+        self,
+        value: t.Any | globus_sdk.MissingType,
+        param: click.Parameter | None,
+        ctx: click.Context | None,
     ) -> str | globus_sdk.MissingType:
         if value is globus_sdk.MISSING:
             return globus_sdk.MISSING
@@ -92,7 +104,10 @@ class OmittableDateTime(_OmittableDateTimeBase):
     name = "datetime"
 
     def convert(
-        self, value: t.Any, param: click.Parameter | None, ctx: click.Context | None
+        self,
+        value: t.Any | globus_sdk.MissingType,
+        param: click.Parameter | None,
+        ctx: click.Context | None,
     ) -> datetime.datetime | globus_sdk.MissingType:
         if value is globus_sdk.MISSING:
             return globus_sdk.MISSING

{globus_cli-3.42.0 → globus_cli-3.43.0}/src/globus_cli/parsing/shared_options/id_args.py

@@ -29,3 +29,7 @@ def flow_id_arg(f: C) -> C:
 
 def run_id_arg(f: C) -> C:
     return click.argument("run_id", metavar="RUN_ID", type=click.UUID)(f)
+
+
+def web_input_id_arg(f: C) -> C:
+    return click.argument("web_input_id", metavar="WEB_INPUT_ID", type=click.UUID)(f)

{globus_cli-3.42.0 → globus_cli-3.43.0}/src/globus_cli/termio/_display.py

@@ -178,8 +178,8 @@ class Renderer:
 
             _assert_iterable(data)
             if text_mode == self.TABLE:
-                if fold_tables():
-                    return FoldedTablePrinter(fields)
+                if (folding_enabled := fold_tables()) is not False:
+                    return FoldedTablePrinter(fields, folding_enabled=folding_enabled)
                 else:
                     return TablePrinter(fields)
             if text_mode == self.RECORD_LIST:

{globus_cli-3.42.0 → globus_cli-3.43.0}/src/globus_cli/termio/context.py

@@ -112,4 +112,4 @@ def term_is_interactive() -> bool:
 
 def fold_tables() -> bool | None:
     val = os.getenv("GLOBUS_CLI_FOLD_TABLES")
-    return val is None or utils.str2bool(val)
+    return None if val is None else utils.str2bool(val)

{globus_cli-3.42.0 → globus_cli-3.43.0}/src/globus_cli/termio/field.py

@@ -13,6 +13,8 @@ class Field:
         name for table output
     :param key: a jmespath expression for indexing into print data
     :param wrap_enabled: in record output, is this field allowed to wrap
+    :param section: in record output, render this field as a standalone,
+        indented block rather than an inline 'key: value' pair
     """
 
     def __init__(
@@ -21,11 +23,13 @@ class Field:
         key: str,
         *,
         wrap_enabled: bool = False,
+        section: bool = False,
         formatter: formatters.FieldFormatter[t.Any] = formatters.Str,
     ) -> None:
         self.name = name
         self.key = key
         self.wrap_enabled = wrap_enabled
+        self.section = section
         self.formatter = formatter
 
     def get_value(self, data: t.Any) -> t.Any: