scim2-cli 0.5.0__tar.gz → 0.6.0__tar.gz

{scim2_cli-0.5.0 → scim2_cli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: scim2-cli
-Version: 0.5.0
+Version: 0.6.0
 Summary: SCIM application development CLI
 Keywords: scim,scim2,provisioning,rfc7643,rfc7644
 Author: Yaal Coop
@@ -218,8 +218,8 @@ Classifier: Environment :: Web Environment
 Classifier: Programming Language :: Python
 Classifier: Operating System :: OS Independent
 Requires-Dist: click>=8.5.0
-Requires-Dist: scim2-client[httpx2]>=0.13.0
-Requires-Dist: scim2-tester>=0.4.0
+Requires-Dist: scim2-client[httpx2]>=0.13.2
+Requires-Dist: scim2-tester>=0.5.1
 Requires-Dist: sphinx-click-rst-to-ansi-formatter>=0.2.0
 Requires-Dist: pydanclick>=0.5.0
 Requires-Dist: pygments>=2.18.0
@@ -243,8 +243,9 @@ It allows users and groups creations, modifications and deletions to be synchron
 
 ## Features
 
-- **CRUD Commands**: `create`, `query`, `replace` and `delete` resources from the command line
+- **CRUD Commands**: `create`, `query`, `replace`, `modify` and `delete` resources from the command line
 - **Search Command**: Query resources using SCIM filters, sorting and pagination
+- **Bulk Command**: Send bulk requests passed as JSON through stdin
 - **Compliance Testing**: Built-in `test` command using [scim2-tester](https://scim2-tester.readthedocs.io) to validate server RFC compliance
 - **Server Discovery**: Automatic retrieval of server schemas and resource types
 - **Dynamic CLI Options**: Command options generated from server schemas

{scim2_cli-0.5.0 → scim2_cli-0.6.0}/README.md

@@ -11,8 +11,9 @@ It allows users and groups creations, modifications and deletions to be synchron
 
 ## Features
 
-- **CRUD Commands**: `create`, `query`, `replace` and `delete` resources from the command line
+- **CRUD Commands**: `create`, `query`, `replace`, `modify` and `delete` resources from the command line
 - **Search Command**: Query resources using SCIM filters, sorting and pagination
+- **Bulk Command**: Send bulk requests passed as JSON through stdin
 - **Compliance Testing**: Built-in `test` command using [scim2-tester](https://scim2-tester.readthedocs.io) to validate server RFC compliance
 - **Server Discovery**: Automatic retrieval of server schemas and resource types
 - **Dynamic CLI Options**: Command options generated from server schemas

{scim2_cli-0.5.0 → scim2_cli-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "scim2-cli"
-version = "0.5.0"
+version = "0.6.0"
 description = "SCIM application development CLI"
 readme = "README.md"
 keywords = [
@@ -30,8 +30,8 @@ classifiers = [
 requires-python = ">= 3.11"
 dependencies = [
     "click>=8.5.0",
-    "scim2-client[httpx2]>=0.13.0",
-    "scim2-tester>=0.4.0",
+    "scim2-client[httpx2]>=0.13.2",
+    "scim2-tester>=0.5.1",
     "sphinx-click-rst-to-ansi-formatter>=0.2.0",
     "pydanclick>=0.5.0",
     "pygments>=2.18.0",

{scim2_cli-0.5.0 → scim2_cli-0.6.0}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "scim2-cli"
-version = "0.5.0"
+version = "0.6.0"
 description = "SCIM application development CLI"
 authors = [{name="Yaal Coop", email="contact@yaal.coop"}]
 license = {file = "LICENSE.md"}
@@ -27,8 +27,8 @@ classifiers = [
 requires-python = ">= 3.11"
 dependencies = [
     "click>=8.5.0",
-    "scim2-client[httpx2]>=0.13.0",
-    "scim2-tester>=0.4.0",
+    "scim2-client[httpx2]>=0.13.2",
+    "scim2-tester>=0.5.1",
     "sphinx-click-rst-to-ansi-formatter>=0.2.0",
     "pydanclick>=0.5.0",
     "pygments>=2.18.0",

scim2_cli-0.6.0/scim2_cli/__init__.py

@@ -0,0 +1,88 @@
+from typing import IO
+
+import click
+from sphinx_click.rst_to_ansi_formatter import make_rst_to_ansi_formatter
+
+from scim2_cli.bulk import bulk_cli
+from scim2_cli.create import create_cli
+from scim2_cli.delete import delete_cli
+from scim2_cli.modify import modify_cli
+from scim2_cli.query import query_cli
+from scim2_cli.replace import replace_cli
+from scim2_cli.search import search_cli
+from scim2_cli.session import Session
+from scim2_cli.test import test_cli
+from scim2_cli.utils import DOC_URL
+from scim2_cli.utils import HeaderType
+from scim2_cli.utils import split_headers
+
+
+@click.group(cls=make_rst_to_ansi_formatter(DOC_URL, group=True))
+@click.option("-u", "--url", help="The SCIM server endpoint.", envvar="SCIM_CLI_URL")
+@click.option(
+    "-h",
+    "--header",
+    multiple=True,
+    type=HeaderType(),
+    help="Headers to pass in the HTTP requests. Can be passed multiple times. Other users of the machine can see the command line arguments, so pass the secrets with the SCIM_CLI_HEADERS environment variable.",
+    envvar="SCIM_CLI_HEADERS",
+)
+@click.option(
+    "--no-verify",
+    is_flag=True,
+    default=False,
+    help="Don't perform https certificate verifications.",
+)
+@click.option(
+    "-s",
+    "--schemas",
+    type=click.File(),
+    help="Path to a JSON file containing a list of SCIM Schemas. Those schemas will be assumed to be available on the server. If unset, they will be downloaded.",
+    envvar="SCIM_CLI_SCHEMAS",
+)
+@click.option(
+    "-r",
+    "--resource-types",
+    type=click.File(),
+    help="Path to a JSON file containing a list of SCIM ResourceType. Those resource types will be assumed to be available on the server. If unset, they will be downloaded.",
+    envvar="SCIM_CLI_RESOURCE_TYPES",
+)
+@click.option(
+    "-c",
+    "--service-provider-config",
+    type=click.File(),
+    help="Path to a JSON file containing the ServiceProviderConfig content of the server. Will be downloaded otherwise.",
+    envvar="SCIM_CLI_SERVICE_PROVIDER_CONFIG",
+)
+@click.pass_context
+def cli(
+    ctx: click.Context,
+    url: str | None,
+    header: list[str],
+    no_verify: bool,
+    schemas: IO[str] | None,
+    resource_types: IO[str] | None,
+    service_provider_config: IO[str] | None,
+) -> None:
+    """SCIM application development CLI."""
+    ctx.obj = Session(
+        url=url,
+        headers=split_headers(header),
+        verify=not no_verify,
+        schemas=schemas,
+        resource_types=resource_types,
+        service_provider_config=service_provider_config,
+    )
+
+
+cli.add_command(create_cli)
+cli.add_command(query_cli)
+cli.add_command(replace_cli)
+cli.add_command(modify_cli)
+cli.add_command(delete_cli)
+cli.add_command(search_cli)
+cli.add_command(bulk_cli)
+cli.add_command(test_cli)
+
+if __name__ == "__main__":  # pragma: no cover
+    cli()

scim2_cli-0.6.0/scim2_cli/bulk.py

@@ -0,0 +1,36 @@
+import click
+from sphinx_click.rst_to_ansi_formatter import make_rst_to_ansi_formatter
+
+from scim2_cli.utils import DOC_URL
+from scim2_cli.utils import SCIM_EXCEPTIONS
+from scim2_cli.utils import echo_response
+from scim2_cli.utils import exception_to_click_error
+from scim2_cli.utils import indent_option
+
+
+@click.command(cls=make_rst_to_ansi_formatter(DOC_URL), name="bulk")
+@indent_option()
+@click.pass_context
+def bulk_cli(ctx: click.Context, indent: bool) -> None:
+    """Perform a `SCIM bulk <https://www.rfc-editor.org/rfc/rfc7644#section-3.7>`_ request.
+
+    The bulk request is passed through stdin in JSON format:
+
+    .. code-block:: bash
+
+        echo '{"schemas": ["urn:ietf:params:scim:api:messages:2.0:BulkRequest"], "Operations": [{"method": "POST", "path": "/Users", "bulkId": "qwerty", "data": {"schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"], "userName": "bjensen@example.com"}}]}' |  bulk
+
+    The request is checked against the bulk capabilities of the server before being sent.
+    """
+    payload = ctx.obj.stdin
+    if not payload:
+        click.echo(ctx.get_help())
+        ctx.exit(1)
+
+    try:
+        response = ctx.obj.client.bulk(payload, raise_scim_errors=False)
+
+    except SCIM_EXCEPTIONS as scim_exc:
+        raise exception_to_click_error(scim_exc) from scim_exc
+
+    echo_response(response, indent)

{scim2_cli-0.5.0 → scim2_cli-0.6.0}/scim2_cli/create.py

@@ -15,9 +15,9 @@ from scim2_cli.utils import DOC_URL
 from scim2_cli.utils import SCIM_EXCEPTIONS
 from scim2_cli.utils import ModelCommand
 from scim2_cli.utils import command_name
+from scim2_cli.utils import echo_response
 from scim2_cli.utils import escape_options_help
 from scim2_cli.utils import exception_to_click_error
-from scim2_cli.utils import formatted_payload
 from scim2_cli.utils import indent_option
 from scim2_cli.utils import inherited
 from scim2_cli.utils import me_option
@@ -44,7 +44,7 @@ def create_payload(
     except SCIM_EXCEPTIONS as scim_exc:
         raise exception_to_click_error(scim_exc) from scim_exc
 
-    click.echo(formatted_payload(response.model_dump(), indent))
+    echo_response(response, indent)
 
 
 def create_factory(
@@ -80,8 +80,8 @@ def create_factory(
 
         .. code-block:: bash
 
-            scim create user \\
-                --user-name "foo" \\
+            scim create user \
+                --user-name "foo" \
                 --emails '[{"value":"foo@bar.example", "primary": true}, {"value": "foo@baz.example"}]'
 
         Input can also be passed through stdin in JSON format:
@@ -101,13 +101,13 @@ def create_factory(
         if obj == model():
             obj = None
 
-        payload = ctx.obj.get("stdin") or obj
+        payload = ctx.obj.stdin or obj
         if not payload:
             click.echo(ctx.get_help())
             ctx.exit(1)
 
         create_payload(
-            ctx.obj["client"],
+            ctx.obj.client,
             resource_type,
             payload,
             inherited(ctx, "cli_indent", cli_indent),
@@ -149,9 +149,9 @@ def create_cli(ctx: click.Context, cli_indent: bool, cli_me: bool) -> None:
     if ctx.invoked_subcommand is not None:
         return
 
-    payload = ctx.obj.get("stdin")
+    payload = ctx.obj.stdin
     if not payload:
         click.echo(ctx.get_help())
         ctx.exit(1)
 
-    create_payload(ctx.obj["client"], None, payload, cli_indent, cli_me)
+    create_payload(ctx.obj.client, None, payload, cli_indent, cli_me)

{scim2_cli-0.5.0 → scim2_cli-0.6.0}/scim2_cli/delete.py

@@ -1,8 +1,6 @@
 import click
 from click import ClickException
 from scim2_client import Me
-from scim2_models import Message
-from scim2_models import Resource
 from sphinx_click.rst_to_ansi_formatter import make_rst_to_ansi_formatter
 
 from scim2_cli.utils import exception_to_click_error
@@ -11,7 +9,7 @@ from scim2_cli.utils import me_option
 
 from .utils import DOC_URL
 from .utils import SCIM_EXCEPTIONS
-from .utils import formatted_payload
+from .utils import echo_response
 
 
 @click.command(cls=make_rst_to_ansi_formatter(DOC_URL), name="delete")
@@ -50,21 +48,12 @@ def delete_cli(
     if not me and not (resource_type and id):
         raise ClickException("Pass a resource type and an id, or --me.")
 
-    target = (
-        find_target(ctx.obj["resource_types"], resource_type) if resource_type else Me
-    )
+    target = find_target(ctx.obj.resource_types, resource_type) if resource_type else Me
 
     try:
-        response = ctx.obj["client"].delete(target, id, raise_scim_errors=False)
+        response = ctx.obj.client.delete(target, id, raise_scim_errors=False)
 
     except SCIM_EXCEPTIONS as scim_exc:
         raise exception_to_click_error(scim_exc) from scim_exc
 
-    if response:
-        payload = (
-            response.model_dump()
-            if isinstance(response, Resource | Message)
-            else response
-        )
-        payload = formatted_payload(payload, indent)
-        click.echo(payload)
+    echo_response(response, indent)

scim2_cli-0.6.0/scim2_cli/modify.py

@@ -0,0 +1,209 @@
+import json
+from decimal import Decimal
+from typing import Any
+
+import click
+from click import ClickException
+from pydantic import ValidationError
+from scim2_client import Me
+from scim2_models import BaseModel
+from scim2_models import Context
+from scim2_models import Error
+from scim2_models import InvalidPathException
+from scim2_models import PatchOp
+from scim2_models import Path
+from scim2_models import Resource
+from scim2_models import SCIMException
+from sphinx_click.rst_to_ansi_formatter import make_rst_to_ansi_formatter
+
+from scim2_cli.utils import DOC_URL
+from scim2_cli.utils import SCIM_EXCEPTIONS
+from scim2_cli.utils import echo_response
+from scim2_cli.utils import escape_control_characters
+from scim2_cli.utils import exception_to_click_error
+from scim2_cli.utils import find_target
+from scim2_cli.utils import indent_option
+from scim2_cli.utils import me_option
+
+OPERATIONS = {"add": 2, "replace": 2, "remove": 1}
+JSON_TYPES = (bool, int, float, Decimal, BaseModel)
+
+
+def parse_operations(tokens: tuple[str, ...]) -> list[tuple[str, str, str | None]]:
+    """Split the arguments into operations, each one followed by its path and its value."""
+    operations: list[tuple[str, str, str | None]] = []
+    index = 0
+    while index < len(tokens):
+        op = tokens[index].lower()
+        if op not in OPERATIONS:
+            raise ClickException(
+                f"Unknown operation '{escape_control_characters(tokens[index])}'. "
+                f"Available values are: {', '.join(OPERATIONS)}"
+            )
+
+        nargs = OPERATIONS[op]
+        arguments = tokens[index + 1 : index + 1 + nargs]
+        if len(arguments) < nargs or (op == "remove" and not arguments[0]):
+            expected = "a path and a value" if nargs == 2 else "a path"
+            raise ClickException(f"The '{op}' operation takes {expected}.")
+
+        path, *value = arguments
+        operations.append((op, path, value[0] if value else None))
+        index += 1 + nargs
+
+    return operations
+
+
+def serves(model: type[Resource[Any]], path: str) -> bool:
+    """Tell whether a path designates an attribute or an extension of a model."""
+    bound = Path[model](path)  # type: ignore[valid-type]
+    return bound.resolve() is not None or bound.model is not None
+
+
+def is_json(model: type[Resource[Any]], path: str) -> bool:
+    """Tell whether the value of an attribute is written in JSON rather than as a plain string."""
+    bound = Path[model](path)  # type: ignore[valid-type]
+    binding = bound.resolve()
+    if binding is None:
+        return True
+
+    if binding.is_multivalued and not binding.sub_field_name and not bound.value_filter:
+        return True
+
+    target = binding.target_type
+    return isinstance(target, type) and issubclass(target, JSON_TYPES)
+
+
+def read_value(model: type[Resource[Any]], path: str, value: str) -> Any:
+    """Read a value with the type of the attribute it is meant for."""
+    if not is_json(model, path):
+        return value
+
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError as exc:
+        raise ClickException(
+            f"Invalid JSON value for '{escape_control_characters(path)}': {exc}"
+        ) from exc
+
+
+def build_patch(
+    models: list[type[Resource[Any]]], operations: list[tuple[str, str, str | None]]
+) -> PatchOp[Resource[Any]]:
+    """Build the patch operation of the first model that has all the attributes."""
+    paths = [path for _, path, _ in operations]
+    for path in paths:
+        try:
+            Path(path)
+        except InvalidPathException as exc:
+            raise ClickException(
+                f"Invalid path '{escape_control_characters(path)}': {exc}"
+            ) from exc
+
+    model = next(
+        (model for model in models if all(serves(model, path) for path in paths)),
+        None,
+    )
+    if model is None:
+        unknown = [
+            path for path in paths if not any(serves(model, path) for model in models)
+        ]
+        message = (
+            "Unknown attributes: "
+            if unknown
+            else "No resource type has all the attributes: "
+        )
+        raise ClickException(
+            message
+            + ", ".join(escape_control_characters(path) for path in unknown or paths)
+        )
+
+    patch_operations = []
+    for op, path, value in operations:
+        operation = {"op": op}
+        if path:
+            operation["path"] = path
+        if value is not None:
+            operation["value"] = read_value(model, path, value)
+        patch_operations.append(operation)
+
+    try:
+        return PatchOp[model].model_validate({"Operations": patch_operations})  # type: ignore[valid-type]
+    except ValidationError as exc:
+        error = Error.from_validation_errors(exc)[0]
+        raise exception_to_click_error(
+            SCIMException.from_error(error, scim_ctx=Context.RESOURCE_PATCH_REQUEST)
+        ) from exc
+
+
+@click.command(cls=make_rst_to_ansi_formatter(DOC_URL), name="modify")
+@click.argument("arguments", nargs=-1, metavar="[RESOURCE_TYPE ID] OPERATION...")
+@me_option()
+@indent_option()
+@click.pass_context
+def modify_cli(
+    ctx: click.Context, arguments: tuple[str, ...], me: bool, indent: bool
+) -> None:
+    r"""Perform a `SCIM PATCH <https://www.rfc-editor.org/rfc/rfc7644#section-3.5.2>`_ request.
+
+    The operations follow the resource type and the id. They are applied in order:
+
+    - :code:`add PATH VALUE` adds a value,
+    - :code:`replace PATH VALUE` replaces a value,
+    - :code:`remove PATH` removes a value.
+
+    .. code-block:: bash
+
+        modify user 1234 replace displayName "Barbara Jensen" \
+            remove 'emails[type eq "work"]' \
+            add emails '[{"value": "bjensen@example.com", "type": "work"}]'
+
+    Values of string attributes are passed as is, the other values are passed in JSON.
+    An empty path applies a JSON object of attributes to the resource.
+    Pass :code:`--` before the operations if a value starts with :code:`-`.
+
+    With :code:`--me`, the request is made on the :code:`/Me` endpoint:
+
+    .. code-block:: bash
+
+        modify --me replace displayName "Barbara Jensen"
+
+    A patch operation can also be passed through stdin in JSON format:
+
+    .. code-block:: bash
+
+        echo '{"schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [{"op": "replace", "value": {"displayName": "Barbara Jensen"}}]}' |  modify user 1234
+
+    """
+    resource_types = ctx.obj.resource_types
+    provider = ctx.obj.client.provider
+    if me and arguments and arguments[0].lower() in resource_types:
+        raise ClickException("--me cannot be used with a resource type or an id.")
+
+    if me:
+        target, id, tokens = Me, None, arguments
+        models = list(
+            dict.fromkeys(provider.model_for(rt) for rt in resource_types.values())
+        )
+    elif len(arguments) < 2:
+        raise ClickException("Pass a resource type and an id, or --me.")
+    else:
+        target = find_target(resource_types, arguments[0])
+        id, tokens = arguments[1], arguments[2:]
+        models = [provider.model_for(target)]
+
+    stdin = ctx.obj.stdin
+    if stdin and tokens:
+        raise ClickException("Pass the operations either as arguments or to stdin.")
+
+    if not stdin and not tokens:
+        raise ClickException("Missing operation.")
+
+    payload = stdin or build_patch(models, parse_operations(tokens))
+    try:
+        response = ctx.obj.client.modify(target, id, payload, raise_scim_errors=False)
+
+    except SCIM_EXCEPTIONS as scim_exc:
+        raise exception_to_click_error(scim_exc) from scim_exc
+
+    echo_response(response, indent)

{scim2_cli-0.5.0 → scim2_cli-0.6.0}/scim2_cli/query.py

@@ -17,7 +17,7 @@ from scim2_cli.utils import me_option
 
 from .utils import DOC_URL
 from .utils import SCIM_EXCEPTIONS
-from .utils import formatted_payload
+from .utils import echo_response
 
 DISCOVERY_MODELS = (Schema, ResourceType, ServiceProviderConfig)
 
@@ -106,7 +106,7 @@ def query_cli(
     target: ResourceType | type[Resource[Any]] | None = None
     if resource_type:
         targets: dict[str, ResourceType | type[Resource[Any]]] = {
-            **ctx.obj["resource_types"],
+            **ctx.obj.resource_types,
             **{model.__name__.lower(): model for model in DISCOVERY_MODELS},
         }
         target = find_target(targets, resource_type)
@@ -129,9 +129,9 @@ def query_cli(
             f"{', '.join(listing_options)} cannot be used when querying a single resource."
         )
 
-    if ctx.obj.get("stdin"):
+    if ctx.obj.stdin:
         check_request_payload = False
-        payload = ctx.obj.get("stdin")
+        payload = ctx.obj.stdin
 
     elif single_resource:
         check_request_payload = True
@@ -158,7 +158,7 @@ def query_cli(
         )
 
     try:
-        response = ctx.obj["client"].query(
+        response = ctx.obj.client.query(
             Me if me else target,
             id,
             query_parameters=payload,
@@ -169,5 +169,4 @@ def query_cli(
     except SCIM_EXCEPTIONS as scim_exc:
         raise exception_to_click_error(scim_exc) from scim_exc
 
-    payload = formatted_payload(response.model_dump(), indent)
-    click.echo(payload)
+    echo_response(response, indent)

{scim2_cli-0.5.0 → scim2_cli-0.6.0}/scim2_cli/replace.py

@@ -21,7 +21,7 @@ from scim2_cli.utils import me_option
 from .utils import DOC_URL
 from .utils import SCIM_EXCEPTIONS
 from .utils import ModelCommand
-from .utils import formatted_payload
+from .utils import echo_response
 from .utils import renamed_fields
 from .utils import unacceptable_fields
 
@@ -45,7 +45,7 @@ def replace_payload(
     except SCIM_EXCEPTIONS as scim_exc:
         raise exception_to_click_error(scim_exc) from scim_exc
 
-    click.echo(formatted_payload(response.model_dump(), indent))
+    echo_response(response, indent)
 
 
 def replace_factory(
@@ -82,9 +82,9 @@ def replace_factory(
 
         .. code-block:: bash
 
-             replace user \\
-                --id "xxxx-yyyy" \\
-                --user-name "foo" \\
+             replace user \
+                --id "xxxx-yyyy" \
+                --user-name "foo" \
                 --emails '[{"value":"foo@bar.example", "primary": true}, {"value": "foo@baz.example"}]'
 
         Input can also be passed through stdin in JSON format:
@@ -104,13 +104,13 @@ def replace_factory(
         if obj == model():
             obj = None
 
-        payload = ctx.obj.get("stdin") or obj
+        payload = ctx.obj.stdin or obj
         if not payload:
             click.echo(ctx.get_help())
             ctx.exit(1)
 
         replace_payload(
-            ctx.obj["client"],
+            ctx.obj.client,
             resource_type,
             payload,
             inherited(ctx, "cli_indent", cli_indent),
@@ -152,9 +152,9 @@ def replace_cli(ctx: click.Context, cli_indent: bool, cli_me: bool) -> None:
     if ctx.invoked_subcommand is not None:
         return
 
-    payload = ctx.obj.get("stdin")
+    payload = ctx.obj.stdin
     if not payload:
         click.echo(ctx.get_help())
         ctx.exit(1)
 
-    replace_payload(ctx.obj["client"], None, payload, cli_indent, cli_me)
+    replace_payload(ctx.obj.client, None, payload, cli_indent, cli_me)

{scim2_cli-0.5.0 → scim2_cli-0.6.0}/scim2_cli/search.py

@@ -7,7 +7,7 @@ from scim2_cli.utils import find_target
 
 from .utils import DOC_URL
 from .utils import SCIM_EXCEPTIONS
-from .utils import formatted_payload
+from .utils import echo_response
 
 
 @click.command(cls=make_rst_to_ansi_formatter(DOC_URL), name="search")
@@ -80,12 +80,12 @@ def search_cli(
 
     """
     target = (
-        find_target(ctx.obj["resource_types"], resource_type) if resource_type else None
+        find_target(ctx.obj.resource_types, resource_type) if resource_type else None
     )
 
-    if ctx.obj.get("stdin"):
+    if ctx.obj.stdin:
         check_request_payload = False
-        payload = ctx.obj.get("stdin")
+        payload = ctx.obj.stdin
 
     else:
         check_request_payload = True
@@ -103,7 +103,7 @@ def search_cli(
         )
 
     try:
-        response = ctx.obj["client"].search(
+        response = ctx.obj.client.search(
             target,
             search_request=payload,
             check_request_payload=check_request_payload,
@@ -113,5 +113,4 @@ def search_cli(
     except SCIM_EXCEPTIONS as scim_exc:
         raise exception_to_click_error(scim_exc) from scim_exc
 
-    payload = formatted_payload(response.model_dump(), indent)
-    click.echo(payload)
+    echo_response(response, indent)

scim2_cli-0.6.0/scim2_cli/session.py

@@ -0,0 +1,132 @@
+import json
+import sys
+from functools import cached_property
+from typing import IO
+from typing import Any
+from typing import TypeVar
+from typing import cast
+
+from click import ClickException
+from httpx2 import Client
+from scim2_client.engines.httpx2 import SyncSCIMClient
+from scim2_models import ListResponse
+from scim2_models import Resource
+from scim2_models import ResourceType
+from scim2_models import Schema
+from scim2_models import ScimProvider
+from scim2_models import ScimProviderError
+from scim2_models import ServiceProviderConfig
+
+from scim2_cli.utils import SCIM_EXCEPTIONS
+from scim2_cli.utils import command_name
+from scim2_cli.utils import escape_control_characters
+from scim2_cli.utils import exception_to_click_error
+
+ResourceT = TypeVar("ResourceT", bound=Resource[Any])
+
+
+def load_objects(fd: IO[str], model: type[ResourceT]) -> list[ResourceT]:
+    """Read a list of objects, bare or wrapped in a ListResponse, from a JSON file."""
+    payload = json.load(fd)
+    if isinstance(payload, dict):
+        list_response: ListResponse[ResourceT] = cast(Any, ListResponse)[
+            model
+        ].model_validate(payload)
+        return list_response.resources or []
+    return [model.model_validate(item) for item in payload]
+
+
+def describe_server(
+    scim_client: SyncSCIMClient,
+    schemas_fd: IO[str] | None,
+    resource_types_fd: IO[str] | None,
+    service_provider_config_fd: IO[str] | None,
+) -> ScimProvider:
+    """Describe the server with the configuration files, and query it for the others."""
+    resource_types = (
+        load_objects(resource_types_fd, ResourceType)
+        if resource_types_fd
+        else cast(
+            "ListResponse[ResourceType]", scim_client.query(ResourceType)
+        ).resources
+        or []
+    )
+    schemas = (
+        load_objects(schemas_fd, Schema)
+        if schemas_fd
+        else cast("ListResponse[Schema]", scim_client.query(Schema)).resources or []
+    )
+    config = (
+        ServiceProviderConfig.model_validate(json.load(service_provider_config_fd))
+        if service_provider_config_fd
+        else cast(ServiceProviderConfig, scim_client.query(ServiceProviderConfig))
+    )
+    return ScimProvider.from_discovery(schemas, resource_types, config)
+
+
+class Session:
+    """What the commands share: the server, discovered on first use, and the standard input."""
+
+    def __init__(
+        self,
+        url: str | None,
+        headers: dict[str, str],
+        verify: bool,
+        schemas: IO[str] | None,
+        resource_types: IO[str] | None,
+        service_provider_config: IO[str] | None,
+    ) -> None:
+        self.url = url
+        self.headers = headers
+        self.verify = verify
+        self.schemas = schemas
+        self.resource_types_file = resource_types
+        self.service_provider_config = service_provider_config
+
+    @cached_property
+    def client(self) -> SyncSCIMClient:
+        """The client of the server, described by the configuration files and the discovery."""
+        if not self.url:
+            raise ClickException("No SCIM server URL defined.")
+
+        client = SyncSCIMClient(
+            Client(base_url=self.url, headers=self.headers, verify=self.verify)
+        )
+        try:
+            client.provider = describe_server(
+                client,
+                self.schemas,
+                self.resource_types_file,
+                self.service_provider_config,
+            )
+        except (*SCIM_EXCEPTIONS, ScimProviderError) as exc:
+            error = exception_to_click_error(exc)
+            raise ClickException(
+                f"Could not discover the server at {escape_control_characters(self.url)}: "
+                f"{error.message}"
+            ) from exc
+        return client
+
+    @cached_property
+    def resource_types(self) -> dict[str, ResourceType]:
+        """The resource types of the server, by command name."""
+        return {
+            command_name(resource_type): resource_type
+            for resource_type in self.client.provider.resource_types
+            if resource_type.name or resource_type.id
+        }
+
+    @cached_property
+    def stdin(self) -> Any:
+        """The JSON payload passed to the standard input, if any."""
+        if sys.stdin.isatty():  # pragma: no cover
+            return None
+
+        payload = sys.stdin.read().strip()
+        if not payload:
+            return None
+
+        try:
+            return json.loads(payload)
+        except json.JSONDecodeError as exc:
+            raise ClickException(f"Invalid JSON input.\n{exc}") from exc

{scim2_cli-0.5.0 → scim2_cli-0.6.0}/scim2_cli/test.py

@@ -34,7 +34,7 @@ def test_cli(
 
          test
     """
-    client = ctx.obj["client"]
+    client = ctx.obj.client
     client.check_response_status_codes = check_status_code
     client.check_response_content_type = check_content_type
     results = check_server(client)

{scim2_cli-0.5.0 → scim2_cli-0.6.0}/scim2_cli/utils.py

@@ -12,7 +12,9 @@ from click import ClickException
 from click.core import ParameterSource
 from scim2_client import SCIMClientException
 from scim2_models import BaseModel
+from scim2_models import BulkResponse
 from scim2_models import Context
+from scim2_models import Error
 from scim2_models import Mutability
 from scim2_models import Resource
 from scim2_models import ResourceType
@@ -129,6 +131,30 @@ def formatted_payload(obj: Any, indent: bool) -> str:
     return json.dumps(obj, indent=INDENTATION_SIZE if indent else None)
 
 
+def echo_response(response: Any, indent: bool) -> None:
+    """Display the response of the server, and exit with an error code if it reports a failure."""
+    if response is None:
+        return
+
+    click.echo(formatted_payload(response.model_dump(), indent))
+    if isinstance(response, Error):
+        summary = " ".join(
+            str(part) for part in (response.status, response.detail) if part
+        )
+        click.echo(f"Error: {escape_control_characters(summary)}", err=True)
+        click.get_current_context().exit(1)
+
+    if isinstance(response, BulkResponse):
+        operations = response.operations or []
+        failed = [op for op in operations if op.status and op.status >= 400]
+        if failed:
+            click.echo(
+                f"Error: {len(failed)} of {len(operations)} bulk operations failed",
+                err=True,
+            )
+            click.get_current_context().exit(1)
+
+
 def split_headers(headers: list[str]) -> dict[str, str]:
     """Make a dict from header strings.
 
@@ -155,16 +181,16 @@ class ModelCommand(RstToAnsiGroup):
         self.factory = factory
 
     def list_commands(self, ctx: click.Context) -> list[str]:
-        ctx.ensure_object(dict)
         base = super().list_commands(ctx)
-        lazy = sorted(ctx.obj.get("resource_types", {}).keys())
-        return base + lazy
+        if ctx.obj is None:
+            return base
+        return base + sorted(ctx.obj.resource_types)
 
     def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None:
-        resource_type = ctx.obj["resource_types"].get(cmd_name.lower())
+        resource_type = ctx.obj.resource_types.get(cmd_name.lower())
         if resource_type is None:
             return None
-        model = ctx.obj["client"].provider.model_for(resource_type)
+        model = ctx.obj.client.provider.model_for(resource_type)
         return self.factory(resource_type, model)
 
 

scim2_cli-0.5.0/scim2_cli/__init__.py

@@ -1,163 +0,0 @@
-import json
-import sys
-from typing import IO
-from typing import Any
-from typing import TypeVar
-from typing import cast
-
-import click
-from httpx2 import Client
-from scim2_client.engines.httpx2 import SyncSCIMClient
-from scim2_models import ListResponse
-from scim2_models import Resource
-from scim2_models import ResourceType
-from scim2_models import Schema
-from scim2_models import ScimProvider
-from scim2_models import ScimProviderError
-from scim2_models import ServiceProviderConfig
-from sphinx_click.rst_to_ansi_formatter import make_rst_to_ansi_formatter
-
-from scim2_cli.create import create_cli
-from scim2_cli.delete import delete_cli
-from scim2_cli.query import query_cli
-from scim2_cli.replace import replace_cli
-from scim2_cli.search import search_cli
-from scim2_cli.test import test_cli
-from scim2_cli.utils import DOC_URL
-from scim2_cli.utils import SCIM_EXCEPTIONS
-from scim2_cli.utils import HeaderType
-from scim2_cli.utils import command_name
-from scim2_cli.utils import exception_to_click_error
-from scim2_cli.utils import split_headers
-
-ResourceT = TypeVar("ResourceT", bound=Resource[Any])
-
-
-def load_objects(fd: IO[str], model: type[ResourceT]) -> list[ResourceT]:
-    """Read a list of objects, bare or wrapped in a ListResponse, from a JSON file."""
-    payload = json.load(fd)
-    if isinstance(payload, dict):
-        list_response: ListResponse[ResourceT] = cast(Any, ListResponse)[
-            model
-        ].model_validate(payload)
-        return list_response.resources or []
-    return [model.model_validate(item) for item in payload]
-
-
-def describe_server(
-    scim_client: SyncSCIMClient,
-    schemas_fd: IO[str] | None,
-    resource_types_fd: IO[str] | None,
-    service_provider_config_fd: IO[str] | None,
-) -> ScimProvider:
-    """Describe the server with the configuration files, and query it for the others."""
-    resource_types = (
-        load_objects(resource_types_fd, ResourceType)
-        if resource_types_fd
-        else cast(
-            "ListResponse[ResourceType]", scim_client.query(ResourceType)
-        ).resources
-        or []
-    )
-    schemas = (
-        load_objects(schemas_fd, Schema)
-        if schemas_fd
-        else cast("ListResponse[Schema]", scim_client.query(Schema)).resources or []
-    )
-    config = (
-        ServiceProviderConfig.model_validate(json.load(service_provider_config_fd))
-        if service_provider_config_fd
-        else cast(ServiceProviderConfig, scim_client.query(ServiceProviderConfig))
-    )
-    return ScimProvider.from_discovery(schemas, resource_types, config)
-
-
-@click.group(cls=make_rst_to_ansi_formatter(DOC_URL, group=True))
-@click.option("-u", "--url", help="The SCIM server endpoint.", envvar="SCIM_CLI_URL")
-@click.option(
-    "-h",
-    "--header",
-    multiple=True,
-    type=HeaderType(),
-    help="Headers to pass in the HTTP requests. Can be passed multiple times. Other users of the machine can see the command line arguments, so pass the secrets with the SCIM_CLI_HEADERS environment variable.",
-    envvar="SCIM_CLI_HEADERS",
-)
-@click.option(
-    "--no-verify",
-    is_flag=True,
-    default=False,
-    help="Don't perform https certificate verifications.",
-)
-@click.option(
-    "-s",
-    "--schemas",
-    type=click.File(),
-    help="Path to a JSON file containing a list of SCIM Schemas. Those schemas will be assumed to be available on the server. If unset, they will be downloaded.",
-    envvar="SCIM_CLI_SCHEMAS",
-)
-@click.option(
-    "-r",
-    "--resource-types",
-    type=click.File(),
-    help="Path to a JSON file containing a list of SCIM ResourceType. Those resource types will be assumed to be available on the server. If unset, they will be downloaded.",
-    envvar="SCIM_CLI_RESOURCE_TYPES",
-)
-@click.option(
-    "-c",
-    "--service-provider-config",
-    type=click.File(),
-    help="Path to a JSON file containing the ServiceProviderConfig content of the server. Will be downloaded otherwise.",
-    envvar="SCIM_CLI_SERVICE_PROVIDER_CONFIG",
-)
-@click.pass_context
-def cli(
-    ctx: click.Context,
-    url: str | None,
-    header: list[str],
-    no_verify: bool,
-    schemas: IO[str] | None,
-    resource_types: IO[str] | None,
-    service_provider_config: IO[str] | None,
-) -> None:
-    """SCIM application development CLI."""
-    ctx.ensure_object(dict)
-
-    if not url:
-        raise click.ClickException("No SCIM server URL defined.")
-
-    headers_dict = split_headers(header)
-    client = Client(base_url=url, headers=headers_dict, verify=not no_verify)
-
-    scim_client = SyncSCIMClient(client)
-    try:
-        scim_client.provider = describe_server(
-            scim_client, schemas, resource_types, service_provider_config
-        )
-    except (*SCIM_EXCEPTIONS, ScimProviderError) as exc:
-        raise exception_to_click_error(exc) from exc
-
-    ctx.obj["client"] = scim_client
-    ctx.obj["resource_types"] = {
-        command_name(resource_type): resource_type
-        for resource_type in scim_client.provider.resource_types
-        if resource_type.name or resource_type.id
-    }
-
-    if not sys.stdin.isatty():  # pragma: no cover
-        if stdin := sys.stdin.read().strip():
-            try:
-                ctx.obj["stdin"] = json.loads(stdin)
-            except json.JSONDecodeError as exc:
-                message = f"Invalid JSON input.\n{exc}"
-                raise click.ClickException(message) from exc
-
-
-cli.add_command(create_cli)
-cli.add_command(query_cli)
-cli.add_command(replace_cli)
-cli.add_command(delete_cli)
-cli.add_command(search_cli)
-cli.add_command(test_cli)
-
-if __name__ == "__main__":  # pragma: no cover
-    cli()