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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: scim2-cli
-Version: 0.4.0
+Version: 0.5.0
 Summary: SCIM application development CLI
 Keywords: scim,scim2,provisioning,rfc7643,rfc7644
 Author: Yaal Coop
@@ -217,10 +217,10 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Environment :: Web Environment
 Classifier: Programming Language :: Python
 Classifier: Operating System :: OS Independent
-Requires-Dist: click>=8.1.7
-Requires-Dist: scim2-client[httpx2]>=0.9.0
+Requires-Dist: click>=8.5.0
+Requires-Dist: scim2-client[httpx2]>=0.13.0
 Requires-Dist: scim2-tester>=0.4.0
-Requires-Dist: sphinx-click-rst-to-ansi-formatter>=0.1.0
+Requires-Dist: sphinx-click-rst-to-ansi-formatter>=0.2.0
 Requires-Dist: pydanclick>=0.5.0
 Requires-Dist: pygments>=2.18.0
 Requires-Python: >=3.11

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

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "scim2-cli"
-version = "0.4.0"
+version = "0.5.0"
 description = "SCIM application development CLI"
 readme = "README.md"
 keywords = [
@@ -29,10 +29,10 @@ classifiers = [
 ]
 requires-python = ">= 3.11"
 dependencies = [
-    "click>=8.1.7",
-    "scim2-client[httpx2]>=0.9.0",
+    "click>=8.5.0",
+    "scim2-client[httpx2]>=0.13.0",
     "scim2-tester>=0.4.0",
-    "sphinx-click-rst-to-ansi-formatter>=0.1.0",
+    "sphinx-click-rst-to-ansi-formatter>=0.2.0",
     "pydanclick>=0.5.0",
     "pygments>=2.18.0",
 ]
@@ -56,7 +56,7 @@ scim2 = "scim2_cli:cli"
 
 [dependency-groups]
 dev = [
-    "mypy>=1.13.0",
+    "mypy>=2.3.1",
     "prek>=0.1.0",
     "pytest>=8.2.1",
     "pytest-cov>=6.0.0",
@@ -85,6 +85,7 @@ scim2-server = false
 scim2-cli = false
 scim2-tester = false
 pytest-scim2-server = false
+sphinx-click-rst-to-ansi-formatter = false
 
 [tool.uv.build-backend]
 module-root = ""
@@ -104,6 +105,7 @@ exclude_lines = [
     "raise NotImplementedError",
     "except ImportError",
     "if app.debug",
+    "if TYPE_CHECKING:",
 ]
 
 [tool.ruff.lint]
@@ -141,6 +143,12 @@ ignore-words-list = "datas"
 
 [tool.mypy]
 plugins = ["pydantic.mypy"]
+files = ["scim2_cli"]
+strict = true
+
+[tool.pydantic-mypy]
+init_forbid_extra = true
+init_typed = true
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

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

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "scim2-cli"
-version = "0.4.0"
+version = "0.5.0"
 description = "SCIM application development CLI"
 authors = [{name="Yaal Coop", email="contact@yaal.coop"}]
 license = {file = "LICENSE.md"}
@@ -26,10 +26,10 @@ classifiers = [
 
 requires-python = ">= 3.11"
 dependencies = [
-    "click>=8.1.7",
-    "scim2-client[httpx2]>=0.9.0",
+    "click>=8.5.0",
+    "scim2-client[httpx2]>=0.13.0",
     "scim2-tester>=0.4.0",
-    "sphinx-click-rst-to-ansi-formatter>=0.1.0",
+    "sphinx-click-rst-to-ansi-formatter>=0.2.0",
     "pydanclick>=0.5.0",
     "pygments>=2.18.0",
 ]
@@ -42,7 +42,7 @@ funding = "https://github.com/sponsors/python-scim"
 
 [dependency-groups]
 dev = [
-    "mypy>=1.13.0",
+    "mypy>=2.3.1",
     "prek>=0.1.0",
     "pytest>=8.2.1",
     "pytest-cov>=6.0.0",
@@ -69,7 +69,8 @@ scim2 = "scim2_cli:cli"
 
 [tool.uv]
 exclude-newer = "14 days"
-exclude-newer-package = { scim2-models = false, scim2-client = false, scim2-server = false, scim2-cli = false, scim2-tester = false, pytest-scim2-server = false }
+# TODO: remove sphinx-click-rst-to-ansi-formatter after 2026-10-20, when 0.2.0 is older than 14 days.
+exclude-newer-package = { scim2-models = false, scim2-client = false, scim2-server = false, scim2-cli = false, scim2-tester = false, pytest-scim2-server = false, sphinx-click-rst-to-ansi-formatter = false }
 
 [tool.uv.build-backend]
 module-root = ""
@@ -89,6 +90,7 @@ exclude_lines = [
     "raise NotImplementedError",
     "except ImportError",
     "if app.debug",
+    "if TYPE_CHECKING:",
 ]
 
 [tool.ruff.lint]
@@ -128,6 +130,12 @@ ignore-words-list = "datas"
 plugins = [
   "pydantic.mypy"
 ]
+files = ["scim2_cli"]
+strict = true
+
+[tool.pydantic-mypy]
+init_forbid_extra = true
+init_typed = true
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{scim2_cli-0.4.0 → scim2_cli-0.5.0}/scim2_cli/__init__.py

@@ -1,10 +1,15 @@
 import json
-import re
+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
@@ -21,37 +26,48 @@ 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 escape_control_characters
+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, model):
+
+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):
-        return ListResponse[model].model_validate(payload).resources or []
+        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, schemas_fd, resource_types_fd, service_provider_config_fd
+    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 scim_client.query(ResourceType).resources or []
+        else cast(
+            "ListResponse[ResourceType]", scim_client.query(ResourceType)
+        ).resources
+        or []
     )
     schemas = (
         load_objects(schemas_fd, Schema)
         if schemas_fd
-        else scim_client.query(Schema).resources or []
+        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 scim_client.query(ServiceProviderConfig)
+        else cast(ServiceProviderConfig, scim_client.query(ServiceProviderConfig))
     )
     return ScimProvider.from_discovery(schemas, resource_types, config)
 
@@ -95,14 +111,14 @@ def describe_server(
 )
 @click.pass_context
 def cli(
-    ctx,
-    url: str,
+    ctx: click.Context,
+    url: str | None,
     header: list[str],
-    no_verify,
-    schemas,
-    resource_types,
-    service_provider_config,
-):
+    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)
 
@@ -120,17 +136,15 @@ def cli(
     except (*SCIM_EXCEPTIONS, ScimProviderError) as exc:
         raise exception_to_click_error(exc) from exc
 
-    provider = scim_client.provider
     ctx.obj["client"] = scim_client
-    ctx.obj["resource_models"] = {
-        escape_control_characters(
-            re.sub(r"\[.*\]", "", resource_model.__name__.lower())
-        ): resource_model
-        for resource_model in map(provider.model_for, provider.resource_types)
+    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 click.get_text_stream("stdin").isatty():  # pragma: no cover
-        if stdin := click.get_text_stream("stdin").read().strip():
+    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:

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

@@ -1,48 +1,73 @@
+from typing import Any
+from typing import cast
+
 import click
-from click import ClickException
 from pydanclick import from_pydantic
+from scim2_client import Me
+from scim2_client.engines.httpx2 import SyncSCIMClient
 from scim2_models import Context
+from scim2_models import Error
+from scim2_models import Resource
+from scim2_models import ResourceType
 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 ModelCommand
+from scim2_cli.utils import command_name
 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
+from scim2_cli.utils import renamed_fields
 from scim2_cli.utils import unacceptable_fields
 
 
-def create_payload(client, payload, indent):
+def create_payload(
+    client: SyncSCIMClient,
+    resource_type: ResourceType | None,
+    payload: Resource[Any] | dict[str, Any],
+    indent: bool,
+    me: bool,
+) -> None:
     try:
-        response = client.create(payload, raise_scim_errors=False)
+        # Response payloads are always checked, so the client never returns a dict.
+        response = cast(
+            "Resource[Any] | Error",
+            client.create(
+                Me if me else resource_type, payload, raise_scim_errors=False
+            ),
+        )
 
     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)
-
+    click.echo(formatted_payload(response.model_dump(), indent))
 
-def create_factory(model):
-    if not model:
-        raise ClickException("Invalid model")
 
+def create_factory(
+    resource_type: ResourceType, model: type[Resource[Any]]
+) -> click.Command:
     exclude = unacceptable_fields(Context.RESOURCE_CREATION_REQUEST, model)
 
     @click.command(
         cls=make_rst_to_ansi_formatter(DOC_URL),
-        name=model.__name__.lower(),
-    )
-    @click.option(
-        "--indent/--no-indent",
-        is_flag=True,
-        default=True,
-        help="Indent JSON response payloads.",
+        name=command_name(resource_type),
     )
-    @from_pydantic("obj", model, exclude=exclude)
+    @indent_option("cli_indent")
+    @me_option("cli_me")
+    @from_pydantic("obj", model, exclude=exclude, rename=renamed_fields(model, exclude))
     @click.pass_context
-    def create_command(ctx, indent, obj: model, *args, **kwargs):
+    def create_command(
+        ctx: click.Context,
+        cli_indent: bool,
+        cli_me: bool,
+        obj: Resource[Any] | None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
         r"""Perform a `SCIM POST <https://www.rfc-editor.org/rfc/rfc7644#section-3.3>`_ request on resources endpoint.
 
         Input data can be passed through parameters like :code:`--external-id`.
@@ -65,6 +90,13 @@ def create_factory(model):
 
             echo '{"userName": "bjensen@example.com", "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"]}' |  create user
 
+        With :code:`--me`, the request is made on the :code:`/Me` endpoint,
+        and the server chooses the resource type:
+
+        .. code-block:: bash
+
+            scim create user --me --user-name "foo"
+
         """
         if obj == model():
             obj = None
@@ -74,7 +106,13 @@ def create_factory(model):
             click.echo(ctx.get_help())
             ctx.exit(1)
 
-        create_payload(ctx.obj["client"], payload, indent)
+        create_payload(
+            ctx.obj["client"],
+            resource_type,
+            payload,
+            inherited(ctx, "cli_indent", cli_indent),
+            inherited(ctx, "cli_me", cli_me),
+        )
 
     return escape_options_help(create_command)
 
@@ -86,16 +124,12 @@ def create_factory(model):
     invoke_without_command=True,
 )
 @click.pass_context
-@click.option(
-    "--indent/--no-indent",
-    is_flag=True,
-    default=True,
-    help="Indent JSON response payloads.",
-)
-def create_cli(ctx, indent):
+@indent_option("cli_indent")
+@me_option("cli_me")
+def create_cli(ctx: click.Context, cli_indent: bool, cli_me: bool) -> None:
     """Perform a `SCIM POST <https://www.rfc-editor.org/rfc/rfc7644#section-3.3>`_ request on resources endpoint.
 
-    There are subcommands for all the available models, with dynamic attributes.
+    There are subcommands for all the resource types of the server, with dynamic attributes.
     See the attributes for :code:`user` with:
 
     .. code-block:: bash
@@ -108,6 +142,9 @@ def create_cli(ctx, indent):
 
         echo '{"userName": "bjensen@example.com", "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"]}' |  create
 
+    With :code:`--me`, the request is made on the :code:`/Me` endpoint,
+    and the server chooses the resource type.
+
     """
     if ctx.invoked_subcommand is not None:
         return
@@ -117,4 +154,4 @@ def create_cli(ctx, indent):
         click.echo(ctx.get_help())
         ctx.exit(1)
 
-    create_payload(ctx.obj["client"], payload, indent)
+    create_payload(ctx.obj["client"], None, payload, cli_indent, cli_me)

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

@@ -1,10 +1,13 @@
 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
+from scim2_cli.utils import find_target
+from scim2_cli.utils import me_option
 
 from .utils import DOC_URL
 from .utils import SCIM_EXCEPTIONS
@@ -12,8 +15,9 @@ from .utils import formatted_payload
 
 
 @click.command(cls=make_rst_to_ansi_formatter(DOC_URL), name="delete")
-@click.argument("resource-type", required=True)
-@click.argument("id", required=True)
+@click.argument("resource-type", required=False)
+@click.argument("id", required=False)
+@me_option()
 @click.option(
     "--indent/--no-indent",
     is_flag=True,
@@ -21,23 +25,37 @@ from .utils import formatted_payload
     help="Indent JSON response payloads.",
 )
 @click.pass_context
-def delete_cli(ctx, resource_type, id, indent):
+def delete_cli(
+    ctx: click.Context,
+    resource_type: str | None,
+    id: str | None,
+    me: bool,
+    indent: bool,
+) -> None:
     """Perform a `SCIM DELETE query <https://www.rfc-editor.org/rfc/rfc7644#section-3.6>`_ request.
 
     .. code-block:: bash
 
          delete user 1234
+
+    With :code:`--me`, the request is made on the :code:`/Me` endpoint:
+
+    .. code-block:: bash
+
+         delete --me
     """
-    try:
-        resource_model = ctx.obj["resource_models"][resource_type]
-    except KeyError as exc:
-        ok_values = ", ".join(ctx.obj["resource_models"])
-        raise ClickException(
-            f"Unknown resource type '{resource_type}'. Available values are: {ok_values}'"
-        ) from exc
+    if me and (resource_type or id):
+        raise ClickException("--me cannot be used with a resource type or an id.")
+
+    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
+    )
 
     try:
-        response = ctx.obj["client"].delete(resource_model, 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

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

@@ -1,5 +1,9 @@
+from typing import Any
+
 import click
 from click import ClickException
+from scim2_client import Me
+from scim2_models import Resource
 from scim2_models import ResourceType
 from scim2_models import ResponseParameters
 from scim2_models import Schema
@@ -8,11 +12,15 @@ from scim2_models import ServiceProviderConfig
 from sphinx_click.rst_to_ansi_formatter import make_rst_to_ansi_formatter
 
 from scim2_cli.utils import exception_to_click_error
+from scim2_cli.utils import find_target
+from scim2_cli.utils import me_option
 
 from .utils import DOC_URL
 from .utils import SCIM_EXCEPTIONS
 from .utils import formatted_payload
 
+DISCOVERY_MODELS = (Schema, ResourceType, ServiceProviderConfig)
+
 
 @click.command(cls=make_rst_to_ansi_formatter(DOC_URL), name="query")
 @click.pass_context
@@ -33,6 +41,10 @@ from .utils import formatted_payload
     type=int,
     help="An integer indicating the 1-based index of the first query result.",
 )
+@click.option(
+    "--cursor",
+    help="The cursor of the page to read, for cursor-based pagination (RFC 9865). Pass an empty value to read the first page.",
+)
 @click.option(
     "--count",
     type=int,
@@ -49,6 +61,7 @@ from .utils import formatted_payload
     "--sort-order",
     help="A string indicating the order in which the “sortBy” parameter is applied.",
 )
+@me_option()
 @click.option(
     "--indent/--no-indent",
     is_flag=True,
@@ -56,23 +69,26 @@ from .utils import formatted_payload
     help="Indent JSON response payloads.",
 )
 def query_cli(
-    ctx,
+    ctx: click.Context,
     resource_type: str | None,
     id: str | None,
     attribute: list[str],
     excluded_attribute: list[str],
-    start_index: int,
-    count: int,
-    filter: str,
-    sort_by: str,
-    sort_order: str,
+    start_index: int | None,
+    cursor: str | None,
+    count: int | None,
+    filter: str | None,
+    sort_by: str | None,
+    sort_order: str | None,
+    me: bool,
     indent: bool,
-):
+) -> None:
     """Perform a `SCIM GET <https://www.rfc-editor.org/rfc/rfc7644#section-3.4.1>`_ request on the :code:`RESOURCE_TYPE` endpoint.
 
     - If :code:`RESOURCE_TYPE` is :code:`user` and :code:`id` is `1234`, then the request will made on the :code:`/Users/1234` endpoint.
     - If :code:`RESOURCE_TYPE` is :code:`user` and :code:`id` is not set, then the request will made on the :code:`/Users` endpoint.
     - If :code:`RESOURCE_TYPE` is not set, then the request will made on the :code:`/` endpoint.
+    - If :code:`--me` is set, then the request will be made on the :code:`/Me` endpoint.
 
     When a single resource is queried, only :code:`--attribute` and :code:`--excluded-attribute` are
     available, as defined in `RFC7644 §3.4.1 <https://www.rfc-editor.org/rfc/rfc7644#section-3.4.1>`_.
@@ -84,23 +100,23 @@ def query_cli(
         echo '{"startIndex": 50, "count": 10}' |  query user
 
     """
-    for model in (Schema, ResourceType, ServiceProviderConfig):
-        ctx.obj["resource_models"][model.__name__.lower()] = model
+    if me and (resource_type or id):
+        raise ClickException("--me cannot be used with a resource type or an id.")
 
+    target: ResourceType | type[Resource[Any]] | None = None
     if resource_type:
-        try:
-            resource_type = ctx.obj["resource_models"][resource_type]
-        except KeyError as exc:
-            ok_values = ", ".join(ctx.obj["resource_models"])
-            raise ClickException(
-                f"Unknown resource type '{resource_type}. Available values are: {ok_values}'"
-            ) from exc
-
-    single_resource = bool(id) or resource_type is ServiceProviderConfig
+        targets: dict[str, ResourceType | type[Resource[Any]]] = {
+            **ctx.obj["resource_types"],
+            **{model.__name__.lower(): model for model in DISCOVERY_MODELS},
+        }
+        target = find_target(targets, resource_type)
+
+    single_resource = me or bool(id) or target is ServiceProviderConfig
     listing_options = [
         name
         for name, value in (
             ("--start-index", start_index),
+            ("--cursor", cursor),
             ("--count", count),
             ("--filter", filter),
             ("--sort-by", sort_by),
@@ -119,26 +135,31 @@ def query_cli(
 
     elif single_resource:
         check_request_payload = True
-        payload = ResponseParameters(
-            attributes=attribute,
-            excluded_attributes=excluded_attribute,
+        payload = ResponseParameters.model_validate(
+            {
+                "attributes": attribute or None,
+                "excluded_attributes": excluded_attribute or None,
+            }
         )
 
     else:
         check_request_payload = True
-        payload = SearchRequest(
-            attributes=attribute,
-            excluded_attributes=excluded_attribute,
-            start_index=start_index,
-            count=count,
-            filter=filter,
-            sort_by=sort_by,
-            sort_order=sort_order,
+        payload = SearchRequest.model_validate(
+            {
+                "attributes": attribute or None,
+                "excluded_attributes": excluded_attribute or None,
+                "start_index": start_index,
+                "cursor": cursor,
+                "count": count,
+                "filter": filter,
+                "sort_by": sort_by,
+                "sort_order": sort_order,
+            }
         )
 
     try:
         response = ctx.obj["client"].query(
-            resource_type,
+            Me if me else target,
             id,
             query_parameters=payload,
             check_request_payload=check_request_payload,

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

@@ -1,50 +1,75 @@
+from typing import Any
+from typing import cast
+
 import click
-from click import ClickException
 from pydanclick import from_pydantic
+from scim2_client import Me
+from scim2_client.engines.httpx2 import SyncSCIMClient
 from scim2_models import Context
+from scim2_models import Error
+from scim2_models import Resource
+from scim2_models import ResourceType
 from sphinx_click.rst_to_ansi_formatter import make_rst_to_ansi_formatter
 
+from scim2_cli.utils import command_name
 from scim2_cli.utils import escape_options_help
 from scim2_cli.utils import exception_to_click_error
+from scim2_cli.utils import indent_option
+from scim2_cli.utils import inherited
+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 renamed_fields
 from .utils import unacceptable_fields
 
 
-def replace_payload(client, payload, indent):
+def replace_payload(
+    client: SyncSCIMClient,
+    resource_type: ResourceType | None,
+    payload: Resource[Any] | dict[str, Any],
+    indent: bool,
+    me: bool,
+) -> None:
     try:
-        response = client.replace(payload, raise_scim_errors=False)
+        # Response payloads are always checked, so the client never returns a dict.
+        response = cast(
+            "Resource[Any] | Error",
+            client.replace(
+                Me if me else resource_type, payload, raise_scim_errors=False
+            ),
+        )
 
     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)
-
+    click.echo(formatted_payload(response.model_dump(), indent))
 
-def replace_factory(model):
-    if not model:
-        raise ClickException("Invalid model")
 
+def replace_factory(
+    resource_type: ResourceType, model: type[Resource[Any]]
+) -> click.Command:
     exclude = unacceptable_fields(Context.RESOURCE_REPLACEMENT_REQUEST, model)
     exclude.remove("id")
 
     @click.command(
         cls=make_rst_to_ansi_formatter(DOC_URL),
-        name=model.__name__.lower(),
+        name=command_name(resource_type),
     )
-    @click.option(
-        "--indent/--no-indent",
-        is_flag=True,
-        default=True,
-        help="Indent JSON response payloads.",
-    )
-    @from_pydantic("obj", model, exclude=exclude)
+    @indent_option("cli_indent")
+    @me_option("cli_me")
+    @from_pydantic("obj", model, exclude=exclude, rename=renamed_fields(model, exclude))
     @click.pass_context
-    def replace_command(ctx, indent, obj: model, *args, **kwargs):
+    def replace_command(
+        ctx: click.Context,
+        cli_indent: bool,
+        cli_me: bool,
+        obj: Resource[Any] | None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
         r"""Perform a `SCIM PUT <https://www.rfc-editor.org/rfc/rfc7644#section-3.3>`_ request on resources endpoint.
 
         Input data can be passed through parameters like :code:`--external-id`.
@@ -68,6 +93,13 @@ def replace_factory(model):
 
             echo '{"id": "xxxx-yyyy", "userName": "bjensen@example.com", "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"]}' |  replace user
 
+        With :code:`--me`, the request is made on the :code:`/Me` endpoint,
+        and :code:`--id` is not needed:
+
+        .. code-block:: bash
+
+            scim replace user --me --user-name "foo"
+
         """
         if obj == model():
             obj = None
@@ -79,8 +111,10 @@ def replace_factory(model):
 
         replace_payload(
             ctx.obj["client"],
+            resource_type,
             payload,
-            indent,
+            inherited(ctx, "cli_indent", cli_indent),
+            inherited(ctx, "cli_me", cli_me),
         )
 
     return escape_options_help(replace_command)
@@ -93,16 +127,12 @@ def replace_factory(model):
     invoke_without_command=True,
 )
 @click.pass_context
-@click.option(
-    "--indent/--no-indent",
-    is_flag=True,
-    default=True,
-    help="Indent JSON response payloads.",
-)
-def replace_cli(ctx, indent):
+@indent_option("cli_indent")
+@me_option("cli_me")
+def replace_cli(ctx: click.Context, cli_indent: bool, cli_me: bool) -> None:
     """Perform a `SCIM PUT <https://www.rfc-editor.org/rfc/rfc7644#section-3.5.1>`_ request on the resources endpoint.
 
-    There are subcommands for all the available models, with dynamic attributes.
+    There are subcommands for all the resource types of the server, with dynamic attributes.
     See the attributes for :code:`user` with:
 
     .. code-block:: bash
@@ -115,6 +145,9 @@ def replace_cli(ctx, indent):
 
         echo '{"userName": "bjensen@example.com", "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"], "id": "1234"}' |  replace user
 
+    With :code:`--me`, the request is made on the :code:`/Me` endpoint,
+    and the id is not needed.
+
     """
     if ctx.invoked_subcommand is not None:
         return
@@ -124,8 +157,4 @@ def replace_cli(ctx, indent):
         click.echo(ctx.get_help())
         ctx.exit(1)
 
-    replace_payload(
-        ctx.obj["client"],
-        payload,
-        indent,
-    )
+    replace_payload(ctx.obj["client"], None, payload, cli_indent, cli_me)

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

@@ -3,6 +3,7 @@ from scim2_models import SearchRequest
 from sphinx_click.rst_to_ansi_formatter import make_rst_to_ansi_formatter
 
 from scim2_cli.utils import exception_to_click_error
+from scim2_cli.utils import find_target
 
 from .utils import DOC_URL
 from .utils import SCIM_EXCEPTIONS
@@ -11,6 +12,7 @@ from .utils import formatted_payload
 
 @click.command(cls=make_rst_to_ansi_formatter(DOC_URL), name="search")
 @click.pass_context
+@click.argument("resource_type", required=False)
 @click.option(
     "--attribute",
     multiple=True,
@@ -26,6 +28,10 @@ from .utils import formatted_payload
     type=int,
     help="An integer indicating the 1-based index of the first query result.",
 )
+@click.option(
+    "--cursor",
+    help="The cursor of the page to read, for cursor-based pagination (RFC 9865). Pass an empty value to read the first page.",
+)
 @click.option(
     "--count",
     type=int,
@@ -49,17 +55,22 @@ from .utils import formatted_payload
     help="Indent JSON response payloads.",
 )
 def search_cli(
-    ctx,
+    ctx: click.Context,
+    resource_type: str | None,
     attribute: list[str],
     excluded_attribute: list[str],
-    start_index: int,
-    count: int,
-    filter: str,
-    sort_by: str,
-    sort_order: str,
+    start_index: int | None,
+    cursor: str | None,
+    count: int | None,
+    filter: str | None,
+    sort_by: str | None,
+    sort_order: str | None,
     indent: bool,
-):
-    """Perform a `SCIM GET <https://www.rfc-editor.org/rfc/rfc7644#section-3.4.1>`_ request on the :code:`/.search` endpoint.
+) -> None:
+    """Perform a `SCIM POST search <https://www.rfc-editor.org/rfc/rfc7644#section-3.4.3>`_ request.
+
+    - If :code:`RESOURCE_TYPE` is :code:`user`, then the request will be made on the :code:`/Users/.search` endpoint.
+    - If :code:`RESOURCE_TYPE` is not set, then the request will be made on the :code:`/.search` endpoint.
 
     Data passed in JSON format to stdin is sent as request arguments and all the other query arguments are ignored:
 
@@ -68,24 +79,32 @@ def search_cli(
         echo '{"startIndex": 50, "count": 10}' |  search user
 
     """
+    target = (
+        find_target(ctx.obj["resource_types"], resource_type) if resource_type else None
+    )
+
     if ctx.obj.get("stdin"):
         check_request_payload = False
         payload = ctx.obj.get("stdin")
 
     else:
         check_request_payload = True
-        payload = SearchRequest(
-            attributes=attribute,
-            excluded_attributes=excluded_attribute,
-            start_index=start_index,
-            count=count,
-            filter=filter,
-            sort_by=sort_by,
-            sort_order=sort_order,
+        payload = SearchRequest.model_validate(
+            {
+                "attributes": attribute or None,
+                "excluded_attributes": excluded_attribute or None,
+                "start_index": start_index,
+                "cursor": cursor,
+                "count": count,
+                "filter": filter,
+                "sort_by": sort_by,
+                "sort_order": sort_order,
+            }
         )
 
     try:
         response = ctx.obj["client"].search(
+            target,
             search_request=payload,
             check_request_payload=check_request_payload,
             raise_scim_errors=False,

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

@@ -25,7 +25,9 @@ from .utils import escape_control_characters
     default=True,
     help="Fail on unexpected content types.",
 )
-def test_cli(ctx, verbose, check_status_code, check_content_type):
+def test_cli(
+    ctx: click.Context, verbose: bool, check_status_code: bool, check_content_type: bool
+) -> None:
     """Perform a server SCIM compliance check using :doc:`scim2-tester <scim2_tester:index>`.
 
     .. code-block:: bash

scim2_cli-0.5.0/scim2_cli/utils.py

@@ -0,0 +1,223 @@
+import json
+import re
+from collections.abc import Callable
+from collections.abc import Mapping
+from enum import StrEnum
+from typing import Any
+from typing import TypeVar
+from typing import cast
+
+import click
+from click import ClickException
+from click.core import ParameterSource
+from scim2_client import SCIMClientException
+from scim2_models import BaseModel
+from scim2_models import Context
+from scim2_models import Mutability
+from scim2_models import Resource
+from scim2_models import ResourceType
+from scim2_models import SCIMException
+from sphinx_click.rst_to_ansi_formatter import RstToAnsiGroup
+
+DOC_URL = "https://scim2-cli.readthedocs.io/"
+INDENTATION_SIZE = 4
+
+SCIM_EXCEPTIONS = (SCIMClientException, SCIMException)
+
+T = TypeVar("T")
+F = TypeVar("F", bound=Callable[..., Any])
+
+COMMAND_OPTIONS = {"me", "indent", "no-indent", "help"}
+
+
+def me_option(*param_decls: str) -> Callable[[F], F]:
+    """Add the --me option, with an optional parameter name."""
+    return click.option(
+        "--me",
+        *param_decls,
+        is_flag=True,
+        default=False,
+        help="Act on the resource of the authenticated client, under /Me (RFC 7644 §3.11).",
+    )
+
+
+def indent_option(*param_decls: str) -> Callable[[F], F]:
+    """Add the --indent option, with an optional parameter name."""
+    return click.option(
+        "--indent/--no-indent",
+        *param_decls,
+        is_flag=True,
+        default=True,
+        help="Indent JSON response payloads.",
+    )
+
+
+CONTROL_CHARACTERS = re.compile(
+    "[\x00-\x08\x0b-\x1f\x7f-\x9f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]"
+)
+
+
+class HeaderType(click.types.StringParamType):
+    envvar_list_splitter = ";"
+    name = "HEADER"
+
+
+class Color(StrEnum):
+    black = "black"
+    red = "red"
+    green = "green"
+    yellow = "yellow"
+    blue = "blue"
+    magenta = "magenta"
+    cyan = "cyan"
+    white = "white"
+    bright_black = "bright_black"
+    bright_red = "bright_red"
+    bright_green = "bright_green"
+    bright_yellow = "bright_yellow"
+    bright_blue = "bright_blue"
+    bright_magenta = "bright_magenta"
+    bright_cyan = "bright_cyan"
+    bright_white = "bright_white"
+
+
+def escape_control_characters(text: object) -> str:
+    """Replace the control characters of a text by their escaped form.
+
+    The texts coming from the server would otherwise be interpreted by the
+    terminal as escape sequences.
+    """
+    return CONTROL_CHARACTERS.sub(
+        lambda match: match.group().encode("unicode_escape").decode(), str(text)
+    )
+
+
+def escape_options_help(command: click.Command) -> click.Command:
+    """Escape the option help texts pydanclick takes from the schema descriptions."""
+    for param in command.params:
+        if isinstance(param, click.Option) and param.help:
+            param.help = escape_control_characters(param.help)
+    return command
+
+
+def command_name(resource_type: ResourceType) -> str:
+    """Name the commands acting on a resource type after its name, or else its id."""
+    return escape_control_characters(resource_type.name or resource_type.id).lower()
+
+
+def find_target(targets: Mapping[str, T], name: str) -> T:
+    """Find what a resource type argument designates, ignoring the case."""
+    try:
+        return targets[name.lower()]
+    except KeyError as exc:
+        ok_values = ", ".join(targets)
+        raise ClickException(
+            f"Unknown resource type '{escape_control_characters(name)}'. "
+            f"Available values are: {ok_values}"
+        ) from exc
+
+
+def inherited(ctx: click.Context, name: str, value: T) -> T:
+    """Read an option of a subcommand, or else the one passed to its parent command."""
+    parent = ctx.parent
+    if parent is None or ctx.get_parameter_source(name) is not ParameterSource.DEFAULT:
+        return value
+    return cast(T, parent.params[name])
+
+
+def formatted_payload(obj: Any, indent: bool) -> str:
+    return json.dumps(obj, indent=INDENTATION_SIZE if indent else None)
+
+
+def split_headers(headers: list[str]) -> dict[str, str]:
+    """Make a dict from header strings.
+
+    ['Authorization: Bearer token'] → '{"Authorization": "Bearer token"}'
+    """
+    return {
+        header[: header.index(":")].strip(): header[header.index(":") + 1 :].strip()
+        for header in headers
+    }
+
+
+class ModelCommand(RstToAnsiGroup):
+    """CLI commands that take a subcommand for each resource type."""
+
+    base_url = DOC_URL
+
+    def __init__(
+        self,
+        *args: Any,
+        factory: Callable[[ResourceType, type[Resource[Any]]], click.Command],
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        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
+
+    def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None:
+        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)
+        return self.factory(resource_type, model)
+
+
+def is_field_acceptable(
+    context: Context, model: type[BaseModel], field_name: str
+) -> bool:
+    """Indicate whether a field is acceptable as part of a SCIM payload for a given context."""
+    mutability = model.get_field_annotation(field_name, Mutability)
+
+    if (
+        context
+        in (Context.RESOURCE_CREATION_REQUEST, Context.RESOURCE_REPLACEMENT_REQUEST)
+        and mutability == Mutability.read_only
+    ):
+        return False
+
+    if (
+        context in (Context.RESOURCE_QUERY_REQUEST, Context.SEARCH_REQUEST)
+        and mutability == Mutability.write_only
+    ):
+        return False
+
+    if (
+        context == Context.RESOURCE_REPLACEMENT_REQUEST
+        and mutability == Mutability.immutable
+    ):
+        return False
+
+    return True
+
+
+def unacceptable_fields(context: Context, model: type[BaseModel]) -> list[str]:
+    excluded = [
+        field_name
+        for field_name in model.model_fields
+        if not is_field_acceptable(context, model, field_name)
+    ]
+    excluded.append("schemas")
+    return excluded
+
+
+def renamed_fields(model: type[BaseModel], exclude: list[str]) -> dict[str, str]:
+    """Rename the options of the attributes that collide with the options of the command."""
+    return {
+        field_name: f"--{option}-attribute"
+        for field_name in model.model_fields
+        if field_name not in exclude
+        and (option := field_name.replace("_", "-")) in COMMAND_OPTIONS
+    }
+
+
+def exception_to_click_error(exception: Exception) -> click.ClickException:
+    message = str(exception)
+    if hasattr(exception, "__notes__"):
+        message += "\n" + "\n".join(exception.__notes__)
+    return click.ClickException(escape_control_characters(message))

scim2_cli-0.4.0/scim2_cli/utils.py

@@ -1,143 +0,0 @@
-import json
-import re
-from enum import StrEnum
-
-import click
-from scim2_client import SCIMClientException
-from scim2_models import SCIMException
-from sphinx_click.rst_to_ansi_formatter import make_rst_to_ansi_formatter
-
-DOC_URL = "https://scim2-cli.readthedocs.io/"
-INDENTATION_SIZE = 4
-
-SCIM_EXCEPTIONS = (SCIMClientException, SCIMException)
-
-CONTROL_CHARACTERS = re.compile(
-    "[\x00-\x08\x0b-\x1f\x7f-\x9f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]"
-)
-
-
-class HeaderType(click.ParamType):
-    envvar_list_splitter = ";"
-    name = "HEADER"
-
-
-class Color(StrEnum):
-    black = "black"
-    red = "red"
-    green = "green"
-    yellow = "yellow"
-    blue = "blue"
-    magenta = "magenta"
-    cyan = "cyan"
-    white = "white"
-    bright_black = "bright_black"
-    bright_red = "bright_red"
-    bright_green = "bright_green"
-    bright_yellow = "bright_yellow"
-    bright_blue = "bright_blue"
-    bright_magenta = "bright_magenta"
-    bright_cyan = "bright_cyan"
-    bright_white = "bright_white"
-
-
-def escape_control_characters(text) -> str:
-    """Replace the control characters of a text by their escaped form.
-
-    The texts coming from the server would otherwise be interpreted by the
-    terminal as escape sequences.
-    """
-    return CONTROL_CHARACTERS.sub(
-        lambda match: match.group().encode("unicode_escape").decode(), str(text)
-    )
-
-
-def escape_options_help(command):
-    """Escape the option help texts pydanclick takes from the schema descriptions."""
-    for param in command.params:
-        if param.help:
-            param.help = escape_control_characters(param.help)
-    return command
-
-
-def formatted_payload(obj, indent):
-    indent = INDENTATION_SIZE if indent else False
-    return json.dumps(obj, indent=indent)
-
-
-def split_headers(headers: list[str]) -> dict[str, str]:
-    """Make a dict from header strings.
-
-    ['Authorization: Bearer token'] → '{"Authorization": "Bearer token"}'
-    """
-    return {
-        header[: header.index(":")].strip(): header[header.index(":") + 1 :].strip()
-        for header in headers
-    }
-
-
-RSTCommand: click.Group = make_rst_to_ansi_formatter(DOC_URL, group=True)
-
-
-class ModelCommand(RSTCommand):
-    """CLI commands that takes a model subcommand."""
-
-    def __init__(self, *args, factory, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.factory = factory
-
-    def list_commands(self, ctx):
-        ctx.ensure_object(dict)
-        base = super().list_commands(ctx)
-        lazy = sorted(ctx.obj.get("resource_models", {}).keys())
-        return base + lazy
-
-    def get_command(self, ctx, cmd_name):
-        model = ctx.obj["resource_models"].get(cmd_name)
-        return self.factory(model)
-
-
-def is_field_acceptable(context, model, field_name) -> bool:
-    """Indicate whether a field is acceptable as part of a SCIM payload for a given context."""
-    from scim2_models import Context
-    from scim2_models import Mutability
-
-    mutability = model.get_field_annotation(field_name, Mutability)
-
-    if (
-        context
-        in (Context.RESOURCE_CREATION_REQUEST, Context.RESOURCE_REPLACEMENT_REQUEST)
-        and mutability == Mutability.read_only
-    ):
-        return False
-
-    if (
-        context in (Context.RESOURCE_QUERY_REQUEST, Context.SEARCH_REQUEST)
-        and mutability == Mutability.write_only
-    ):
-        return False
-
-    if (
-        context == Context.RESOURCE_REPLACEMENT_REQUEST
-        and mutability == Mutability.immutable
-    ):
-        return False
-
-    return True
-
-
-def unacceptable_fields(context, model):
-    excluded = [
-        field_name
-        for field_name in model.model_fields
-        if not is_field_acceptable(context, model, field_name)
-    ]
-    excluded.append("schemas")
-    return excluded
-
-
-def exception_to_click_error(exception):
-    message = str(exception)
-    if hasattr(exception, "__notes__"):
-        message += "\n" + "\n".join(exception.__notes__)
-    return click.ClickException(escape_control_characters(message))