PyPDFForm 5.3.0__tar.gz → 5.4.0__tar.gz

{pypdfform-5.3.0 → pypdfform-5.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPDFForm
-Version: 5.3.0
+Version: 5.4.0
 Summary: The Python library & CLI for PDF forms.
 Author: Jinge Li
 License-Expression: MIT
@@ -121,15 +121,3 @@ The official documentation can be found on [the GitHub page](https://chinapandam
 <!-- TODO: remove WIP when finish recording -->
 * [(WIP) Video Tutorials](https://youtube.com/playlist?list=PLNz_PBu1QA-gzYg5BvyOO98q15u5Xve1L&si=8MWasKEckBzY-NRQ)
 * [Chicago Python User Group - Dec 14, 2023](https://youtu.be/8t1RdAKwr9w?si=TLgumBNXv9H8szSn)
-
-## Star History
-
-This project is maintained entirely in my spare time. If you like the project please consider starring the GitHub repository. It is the best way to keep me motivated and continue making the project better.
-
-<a href="https://www.star-history.com/?repos=chinapandaman%2FPyPDFForm&type=date&logscale=&legend=top-left">
- <picture>
-   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/chart?repos=chinapandaman/PyPDFForm&type=date&theme=dark&legend=top-left" />
-   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/chart?repos=chinapandaman/PyPDFForm&type=date&legend=top-left" />
-   <img alt="Star History Chart" src="https://api.star-history.com/chart?repos=chinapandaman/PyPDFForm&type=date&legend=top-left" />
- </picture>
-</a>

{pypdfform-5.3.0 → pypdfform-5.4.0}/PyPDFForm/__init__.py

@@ -18,7 +18,7 @@ from Python code or from the command line.
 
 import logging
 
-__version__ = "5.3.0"
+__version__ = "5.4.0"
 
 from .lib.annotations import Annotations
 from .lib.assets.blank import BlankPage

{pypdfform-5.3.0 → pypdfform-5.4.0}/PyPDFForm/cli/common.py

@@ -137,6 +137,41 @@ def _input_file_kind(data: Path) -> str:
     return "JSON"
 
 
+def _validate_input_data(
+    input_data: Any,
+    schema: dict,
+    source: str,
+    param_hint: str,
+) -> Any:
+    """
+    Validates parsed CLI input against a JSON schema.
+
+    Args:
+        input_data (Any): Parsed input data to validate.
+        schema (dict): JSON schema to validate against.
+        source (str): User-facing description of the input source.
+        param_hint (str): CLI parameter associated with the input.
+
+    Returns:
+        Any: The validated input data.
+
+    Raises:
+        typer.BadParameter: Raised when validation fails.
+    """
+    try:
+        validate(instance=input_data, schema=schema)
+    except ValidationError as exc:
+        error_path = _validation_error_path(exc)
+        location = f" at {error_path}" if error_path else ""
+        cli_bad_parameter(
+            f"Invalid {source}{location}: {exc.message}",
+            param_hint=param_hint,
+            cause=exc,
+        )
+
+    return input_data
+
+
 def load_data_file(data: Path, schema: dict, param_hint: str) -> Any:
     """
     Loads a YAML or JSON CLI input file and validates it against a schema.
@@ -164,18 +199,53 @@ def load_data_file(data: Path, schema: dict, param_hint: str) -> Any:
             cause=exc,
         )
 
+    return _validate_input_data(
+        input_data,
+        schema,
+        f"{input_kind} file",
+        param_hint,
+    )
+
+
+def load_data_options(options: list[str], schema: dict, param_hint: str) -> Any:
+    """
+    Parses command-line data options and validates them against a schema.
+
+    Options use ``--name value`` syntax. Each value is parsed with
+    :func:`yaml.safe_load`.
+
+    Args:
+        options (list[str]): Unrecognized command arguments captured by Typer.
+        schema (dict): JSON schema to validate the resulting option mapping
+            against.
+        param_hint (str): CLI parameter description used in error messages.
+
+    Returns:
+        Any: Parsed and validated option data.
+
+    Raises:
+        typer.BadParameter: Raised when the options cannot be parsed or the
+            resulting mapping fails validation.
+    """
+    if any(not option.startswith("--") for option in options[::2]):
+        cli_bad_parameter(
+            "Use '--name value' pairs with valid values.",
+            param_hint=param_hint,
+        )
+
     try:
-        validate(instance=input_data, schema=schema)
-    except ValidationError as exc:
-        error_path = _validation_error_path(exc)
-        location = f" at {error_path}" if error_path else ""
+        input_data = {
+            option[2:]: yaml.safe_load(value)
+            for option, value in zip(options[::2], options[1::2], strict=True)
+        }
+    except (ValueError, yaml.YAMLError) as exc:
         cli_bad_parameter(
-            f"Invalid {input_kind} file{location}: {exc.message}",
+            "Use '--name value' pairs with valid values.",
             param_hint=param_hint,
             cause=exc,
         )
 
-    return input_data
+    return _validate_input_data(input_data, schema, "CLI options", param_hint)
 
 
 def get_widget(wrapper: PdfWrapper, field: str, param_hint: str) -> Widget:
@@ -209,62 +279,88 @@ def handle_font_registration(
     """
     Registers a custom font referenced by CLI input.
 
-    CLI input files may provide a file path in a `font` parameter. This helper
+    CLI input may provide a file path in a `font` parameter. This helper
     registers each unique font path on the supplied `PdfWrapper` once, assigns
     it a generated internal font name, and mutates `params["font"]` to that
     registered name so downstream field or element constructors can use it.
 
     Args:
         obj (PdfWrapper): The wrapper for the PDF currently being modified.
-        params (dict): The element or widget parameters loaded from the input
-            file. This dictionary is mutated when it contains a `font` key.
-        registered_font (dict): Mapping of source font paths to generated
-            `PdfWrapper` font names for the current command invocation.
+        params (dict): The element or widget parameters loaded from CLI input.
+            This dictionary is mutated when it contains a `font` key.
+        registered_font (dict): Mapping of resolved source font paths to
+            generated `PdfWrapper` font names for the current command
+            invocation.
     """
     if "font" in params:
-        if params["font"] not in registered_font:
+        font_path = str(Path(params["font"]).resolve())
+        if font_path not in registered_font:
             font_name = f"new_font_{len(registered_font)}"
-            obj.register_font(font_name, params["font"])
-            registered_font[params["font"]] = font_name
-        params["font"] = registered_font[params["font"]]
+            obj.register_font(font_name, font_path)
+            registered_font[font_path] = font_name
+        params["font"] = registered_font[font_path]
 
 
 def create_elements_from_file(
     pdf: Path,
-    data: Path,
+    data: Path | None,
     element_map: dict,
     schema: dict,
     method_name: str,
     ctx: typer.Context,
-    param_hint: str,
+    file_param_hint: str,
+    options_param_hint: str,
     output: Path | None = None,
+    element_type: str | None = None,
 ) -> None:
     """
-    Creates PDF elements from grouped file definitions.
+    Creates PDF elements from a data file or command-line options.
 
-    The input data is expected to group element definitions by type, such as
-    `text`, `image`, or `highlight`. Each group key is resolved through
-    `element_map`, each item is constructed after optional font registration,
-    and the resulting objects are passed to `method_name` on `PdfWrapper`.
-    The modified PDF is written to `output` or back to the input path.
+    A data file groups element definitions by type, such as `text`, `image`, or
+    `highlight`. Without a data file, one element of `element_type` is created
+    from the additional command-line options stored in ``ctx.args``. The data
+    file takes precedence when both input forms are supplied. Each definition
+    is constructed after optional font registration and passed to `method_name`
+    on `PdfWrapper`.
 
     Args:
         pdf (Path): The path to the input PDF file.
-        data (Path): The path to the input file containing grouped element
-            definitions.
+        data (Path, optional): The path to the input file containing grouped
+            element definitions. Defaults to None.
         element_map (dict): Mapping from input group names to element classes
             or callables used to construct each object.
-        schema (dict): JSON schema used to validate the grouped definitions.
+        schema (dict): JSON schema used to validate file or command-line input.
         method_name (str): Name of the `PdfWrapper` method that accepts the
             constructed elements, such as `bulk_create_fields`, `draw`, or
             `annotate`.
         ctx (typer.Context): Typer context containing global wrapper options in
             `ctx.obj`.
-        param_hint (str): CLI parameter associated with the input file.
+        file_param_hint (str): CLI parameter associated with the input file.
+        options_param_hint (str): CLI parameter description associated with
+            command-line options.
         output (Path, optional): Path where the modified PDF should be saved. If
             omitted, the input PDF is overwritten. Defaults to None.
+        element_type (str, optional): Element type selected for command-line
+            input. Defaults to None.
     """
-    input_data = load_data_file(data, schema, param_hint)
+    if data is not None:
+        input_data = load_data_file(data, schema, file_param_hint)
+    else:
+        if element_type not in element_map:
+            choices = ", ".join(element_map)
+            cli_bad_parameter(
+                f"Choose one of: {choices}.",
+                param_hint="--type",
+            )
+        input_data = {
+            element_type: [
+                load_data_options(
+                    ctx.args,
+                    schema["properties"][element_type]["items"],
+                    options_param_hint,
+                )
+            ]
+        }
 
     obj = PdfWrapper(str(pdf), **ctx.obj)
     ungrouped_input = []

{pypdfform-5.3.0 → pypdfform-5.4.0}/PyPDFForm/cli/create.py

@@ -188,33 +188,43 @@ def merge(
 
 
 @create_cli.command(
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
     no_args_is_help=True,
-    help="Add form fields to a PDF.",
+    help="Add form fields from a YAML or JSON file or command-line options.",
 )
 def field(
     ctx: typer.Context,
     pdf: INPUT_PDF,
     data: Annotated[
-        Path, data_file_option("YAML or JSON file with form field definitions.")
-    ],
+        Path | None, data_file_option("YAML or JSON file with form field definitions.")
+    ] = None,
     output: OPTIONAL_OUTPUT_PDF = None,
+    element_type: Annotated[
+        str | None,
+        typer.Option("--type", help="Type of form field to create without --file."),
+    ] = None,
 ) -> None:
     """
-    Add form fields described by grouped YAML or JSON definitions.
+    Add form fields from a data file or command-line options.
 
     The command maps input groups such as `text`, `check`, and `signature` to
-    PyPDFForm field classes, validates the input file against the CLI field
-    schema, creates the corresponding field objects, and calls
-    `PdfWrapper.bulk_create_fields` before writing the modified PDF.
+    PyPDFForm field classes, validates the input against the CLI field schema,
+    creates the corresponding field objects, and calls
+    `PdfWrapper.bulk_create_fields` before writing the modified PDF. A data file
+    can define multiple fields grouped by type. Without `--file`, `--type` and
+    the field options define one field. The data file takes precedence when
+    both input forms are supplied.
 
     Args:
         ctx (typer.Context): Typer context containing global `PdfWrapper`
             options in `ctx.obj`.
         pdf (Path): Input PDF path.
-        data (Path): YAML or JSON file containing grouped form field
-            definitions.
+        data (Path, optional): YAML or JSON file containing grouped form field
+            definitions. Defaults to None.
         output (Path, optional): Output PDF path. If omitted, the input PDF is
             overwritten. Defaults to None.
+        element_type (str, optional): Form field type used when `data` is
+            omitted. Defaults to None.
     """
     field_map = {
         "text": Fields.TextField,
@@ -231,39 +241,51 @@ def field(
         schema=FIELD_SCHEMA,
         method_name="bulk_create_fields",
         ctx=ctx,
-        param_hint="--file",
+        file_param_hint="--file",
+        options_param_hint="field options",
         output=output,
+        element_type=element_type,
     )
 
 
 @create_cli.command(
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
     no_args_is_help=True,
-    help="Draw text, images, and shapes on a PDF.",
+    help="Draw elements from a YAML or JSON file or command-line options.",
 )
 def raw(
     ctx: typer.Context,
     pdf: INPUT_PDF,
     data: Annotated[
-        Path, data_file_option("YAML or JSON file with raw element definitions.")
-    ],
+        Path | None, data_file_option("YAML or JSON file with raw element definitions.")
+    ] = None,
     output: OPTIONAL_OUTPUT_PDF = None,
+    element_type: Annotated[
+        str | None,
+        typer.Option("--type", help="Type of element to draw without --file."),
+    ] = None,
 ) -> None:
     """
-    Draw raw elements described by grouped YAML or JSON definitions.
+    Draw elements from a data file or command-line options.
 
     The command maps input groups such as `text`, `image`, and `rectangle` to
-    raw element classes, validates the input file against the CLI raw element
-    schema, creates the corresponding drawable objects, and calls
-    `PdfWrapper.draw` before writing the modified PDF.
+    raw element classes, validates the input against the CLI raw element schema,
+    creates the corresponding drawable objects, and calls `PdfWrapper.draw`
+    before writing the modified PDF. A data file can define multiple elements
+    grouped by type. Without `--file`, `--type` and the element options define
+    one element. The data file takes precedence when both input forms are
+    supplied.
 
     Args:
         ctx (typer.Context): Typer context containing global `PdfWrapper`
             options in `ctx.obj`.
         pdf (Path): Input PDF path.
-        data (Path): YAML or JSON file containing grouped raw element
-            definitions.
+        data (Path, optional): YAML or JSON file containing grouped raw element
+            definitions. Defaults to None.
         output (Path, optional): Output PDF path. If omitted, the input PDF is
             overwritten. Defaults to None.
+        element_type (str, optional): Element type used when `data` is omitted.
+            Defaults to None.
     """
     raw_element_map = {
         "text": RawElements.RawText,
@@ -280,39 +302,51 @@ def raw(
         schema=RAW_SCHEMA,
         method_name="draw",
         ctx=ctx,
-        param_hint="--file",
+        file_param_hint="--file",
+        options_param_hint="element options",
         output=output,
+        element_type=element_type,
     )
 
 
 @create_cli.command(
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
     no_args_is_help=True,
-    help="Add annotations to a PDF.",
+    help="Add annotations from a YAML or JSON file or command-line options.",
 )
 def annotation(
     ctx: typer.Context,
     pdf: INPUT_PDF,
     data: Annotated[
-        Path, data_file_option("YAML or JSON file with annotation definitions.")
-    ],
+        Path | None, data_file_option("YAML or JSON file with annotation definitions.")
+    ] = None,
     output: OPTIONAL_OUTPUT_PDF = None,
+    element_type: Annotated[
+        str | None,
+        typer.Option("--type", help="Type of annotation to add without --file."),
+    ] = None,
 ) -> None:
     """
-    Add annotations described by grouped YAML or JSON definitions.
+    Add annotations from a data file or command-line options.
 
     The command maps input groups such as `text`, `link`, and `highlight` to
-    annotation classes, validates the input file against the CLI annotation
-    schema, creates the corresponding annotation objects, and calls
-    `PdfWrapper.annotate` before writing the modified PDF.
+    annotation classes, validates the input against the CLI annotation schema,
+    creates the corresponding annotation objects, and calls
+    `PdfWrapper.annotate` before writing the modified PDF. A data file can
+    define multiple annotations grouped by type. Without `--file`, `--type` and
+    the annotation options define one annotation. The data file takes
+    precedence when both input forms are supplied.
 
     Args:
         ctx (typer.Context): Typer context containing global `PdfWrapper`
             options in `ctx.obj`.
         pdf (Path): Input PDF path.
-        data (Path): YAML or JSON file containing grouped annotation
-            definitions.
+        data (Path, optional): YAML or JSON file containing grouped annotation
+            definitions. Defaults to None.
         output (Path, optional): Output PDF path. If omitted, the input PDF is
             overwritten. Defaults to None.
+        element_type (str, optional): Annotation type used when `data` is
+            omitted. Defaults to None.
     """
     annotation_map = {
         "text": Annotations.TextAnnotation,
@@ -330,8 +364,10 @@ def annotation(
         schema=ANNOTATION_SCHEMA,
         method_name="annotate",
         ctx=ctx,
-        param_hint="--file",
+        file_param_hint="--file",
+        options_param_hint="annotation options",
         output=output,
+        element_type=element_type,
     )
 
 

{pypdfform-5.3.0 → pypdfform-5.4.0}/PyPDFForm/cli/root.py

@@ -8,7 +8,7 @@ commands. The root callback collects global flags in the Typer context so each
 subcommand can initialize `PdfWrapper` with consistent settings.
 
 Commands:
-    - `fill`: Fill an existing PDF form from YAML or JSON data.
+    - `fill`: Fill an existing PDF form from a data file or field options.
     - `create`: Create PDFs, fields, annotations, raw elements, and grid views.
     - `inspect`: Print form metadata and field data as JSON.
     - `update`: Modify PDF metadata, field names, properties, geometry, and scripts.
@@ -21,7 +21,13 @@ from typing import Annotated
 import typer
 
 from .. import PdfWrapper, Widgets, __version__
-from .common import INPUT_PDF, OPTIONAL_OUTPUT_PDF, data_file_option, load_data_file
+from .common import (
+    INPUT_PDF,
+    OPTIONAL_OUTPUT_PDF,
+    data_file_option,
+    load_data_file,
+    load_data_options,
+)
 from .create import create_cli
 from .inspect import inspect_cli
 from .remove import remove_cli
@@ -144,15 +150,16 @@ def main(
 
 
 @cli_app.command(
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
     no_args_is_help=True,
-    help="Fill a PDF form with YAML or JSON data.",
+    help="Fill a PDF form from a YAML or JSON file or command-line options.",
 )
 def fill(
     ctx: typer.Context,
     pdf: INPUT_PDF,
     data: Annotated[
-        Path, data_file_option("YAML or JSON file with form field values.")
-    ],
+        Path | None, data_file_option("YAML or JSON file with form field values.")
+    ] = None,
     output: OPTIONAL_OUTPUT_PDF = None,
     flatten: Annotated[
         bool,
@@ -160,19 +167,22 @@ def fill(
     ] = None,
 ) -> None:
     """
-    Fill an existing PDF form from a validated YAML or JSON file.
+    Fill an existing PDF form from a data file or command-line options.
 
     The command loads the input PDF with the global options stored by the root
     callback, expands the generated schema so image and signature widgets can
-    accept path objects, validates the input file, normalizes image and
+    accept path objects, validates the input data, normalizes image and
     signature values, and writes the filled PDF to the requested output path or
-    back to the input file.
+    back to the input file. When both a data file and field options are supplied,
+    the data file takes precedence.
 
     Args:
         ctx (typer.Context): Typer context containing global `PdfWrapper`
             options in `ctx.obj`.
         pdf (Path): Input PDF form path.
-        data (Path): YAML or JSON file containing form field values.
+        data (Path, optional): YAML or JSON file containing form field values.
+            When omitted, form field values are read from the command-line
+            options in ``ctx.args``. Defaults to None.
         output (Path, optional): Output PDF path. If omitted, the input PDF is
             overwritten. Defaults to None.
         flatten (bool, optional): Whether to flatten form fields after filling.
@@ -198,7 +208,11 @@ def fill(
                 ]
             }
 
-    input_data = load_data_file(data, schema, "--file")
+    input_data = (
+        load_data_file(data, schema, "--file")
+        if data is not None
+        else load_data_options(ctx.args, schema, "form field options")
+    )
     for k, each in obj.widgets.items():
         if (
             k in input_data

{pypdfform-5.3.0 → pypdfform-5.4.0}/PyPDFForm/cli/update.py

@@ -26,6 +26,7 @@ from .common import (
     get_widget,
     handle_font_registration,
     load_data_file,
+    load_data_options,
 )
 from .schemas.update import FIELD_SCHEMA, RENAME_SCHEMA
 
@@ -185,33 +186,46 @@ def bounds(
 
 
 @update_cli.command(
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
     no_args_is_help=True,
-    help="Rename form fields from YAML or JSON.",
+    help="Rename form fields from YAML or JSON or command-line options.",
 )
 def rename(
     ctx: typer.Context,
     pdf: INPUT_PDF,
     data: Annotated[
-        Path, data_file_option("YAML or JSON file with form field renames.")
-    ],
+        Path | None, data_file_option("YAML or JSON file with form field renames.")
+    ] = None,
     output: OPTIONAL_OUTPUT_PDF = None,
+    widget: Annotated[
+        str | None,
+        typer.Option(
+            "--field",
+            help="Form field name to rename without --file.",
+        ),
+    ] = None,
 ) -> None:
     """
-    Rename form fields using a validated YAML or JSON mapping file.
+    Rename form fields from a data file or command-line options.
 
-    The command rejects full widget name mode, validates the input file against
-    the rename schema, resolves each existing field, queues the requested key
+    The command rejects full widget name mode, validates the input against the
+    rename schema, resolves each existing field, queues the requested key
     updates on the `PdfWrapper`, commits the rename operations, and writes the
-    modified PDF to the requested output path or back to the input file.
+    modified PDF to the requested output path or back to the input file. A data
+    file can rename multiple fields. Without `--file`, `--field` and the rename
+    options update one field. The data file takes precedence when both input
+    forms are supplied.
 
     Args:
         ctx (typer.Context): Typer context containing global `PdfWrapper`
             options in `ctx.obj`.
         pdf (Path): Input PDF path.
-        data (Path): YAML or JSON file containing form field rename
-            definitions.
+        data (Path, optional): YAML or JSON file containing form field rename
+            definitions. Defaults to None.
         output (Path, optional): Output PDF path. If omitted, the input PDF is
             overwritten. Defaults to None.
+        widget (str, optional): Form field name used when `data` is omitted.
+            Defaults to None.
 
     Raises:
         typer.BadParameter: Raised when full widget name mode is enabled, the
@@ -224,59 +238,111 @@ def rename(
             param_hint="--use-full-widget-name",
         )
 
-    input_data = load_data_file(data, RENAME_SCHEMA, "--file")
+    if data is not None:
+        input_data = load_data_file(data, RENAME_SCHEMA, "--file")
+        field_param_hint = "--file"
+    else:
+        if widget is None:
+            cli_bad_parameter(
+                "Specify a form field when --file is omitted.",
+                param_hint="--field",
+            )
+        input_data = [
+            {
+                widget: load_data_options(
+                    ctx.args,
+                    RENAME_SCHEMA["items"]["additionalProperties"],
+                    "rename options",
+                )
+            }
+        ]
+        field_param_hint = "--field"
 
     obj = PdfWrapper(str(pdf), **ctx.obj)
     for item in input_data:
         for k, v in item.items():
-            widget = get_widget(obj, k, "--file")
-            obj.update_widget_key(widget.name, v["new_key"], index=v.get("index", 0))
+            field_widget = get_widget(obj, k, field_param_hint)
+            obj.update_widget_key(
+                field_widget.name,
+                v["new_key"],
+                index=v.get("index", 0),
+            )
 
     obj.commit_widget_key_updates().write(output or pdf)
 
 
 @update_cli.command(
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
     no_args_is_help=True,
-    help="Update form field properties from YAML or JSON.",
+    help="Update form field properties from YAML or JSON or command-line options.",
 )
 def field(
     ctx: typer.Context,
     pdf: INPUT_PDF,
     data: Annotated[
-        Path, data_file_option("YAML or JSON file with form field property updates.")
-    ],
+        Path | None,
+        data_file_option("YAML or JSON file with form field property updates."),
+    ] = None,
     output: OPTIONAL_OUTPUT_PDF = None,
+    widget: Annotated[
+        str | None,
+        typer.Option(
+            "--field",
+            help="Form field name to update without --file.",
+        ),
+    ] = None,
 ) -> None:
     """
-    Update form field properties from a validated YAML or JSON file.
+    Update form field properties from a data file or command-line options.
 
-    The command validates the input file against the field update schema, loads
-    the PDF with the global CLI options stored in `ctx.obj`, resolves each
-    field name, registers any referenced fonts once per invocation, assigns the
+    The command validates the input against the field update schema, loads the
+    PDF with the global CLI options stored in `ctx.obj`, resolves each field
+    name, registers any referenced fonts once per invocation, assigns the
     requested widget properties, and writes the modified PDF to the requested
-    output path or back to the input file.
+    output path or back to the input file. A data file can update multiple
+    fields. Without `--file`, `--field` and the property options update one
+    field. The data file takes precedence when both input forms are supplied.
 
     Args:
         ctx (typer.Context): Typer context containing global `PdfWrapper`
             options in `ctx.obj`.
         pdf (Path): Input PDF path.
-        data (Path): YAML or JSON file containing form field property updates.
+        data (Path, optional): YAML or JSON file containing form field property
+            updates. Defaults to None.
         output (Path, optional): Output PDF path. If omitted, the input PDF is
             overwritten. Defaults to None.
+        widget (str, optional): Form field name used when `data` is omitted.
+            Defaults to None.
 
     Raises:
         typer.BadParameter: Raised when the input file is invalid or a requested
             field does not exist.
     """
-    input_data = load_data_file(data, FIELD_SCHEMA, "--file")
+    if data is not None:
+        input_data = load_data_file(data, FIELD_SCHEMA, "--file")
+        field_param_hint = "--file"
+    else:
+        if widget is None:
+            cli_bad_parameter(
+                "Specify a form field when --file is omitted.",
+                param_hint="--field",
+            )
+        input_data = {
+            widget: load_data_options(
+                ctx.args,
+                FIELD_SCHEMA["patternProperties"][".+"],
+                "field update options",
+            )
+        }
+        field_param_hint = "--field"
 
     obj = PdfWrapper(str(pdf), **ctx.obj)
     registered_font = {}
     for k, each in input_data.items():
-        widget = get_widget(obj, k, "--file")
+        field_widget = get_widget(obj, k, field_param_hint)
         handle_font_registration(obj, each, registered_font)
         for param, v in each.items():
-            setattr(widget, param, v)
+            setattr(field_widget, param, v)
 
     obj.write(output or pdf)
 

{pypdfform-5.3.0 → pypdfform-5.4.0}/PyPDFForm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPDFForm
-Version: 5.3.0
+Version: 5.4.0
 Summary: The Python library & CLI for PDF forms.
 Author: Jinge Li
 License-Expression: MIT
@@ -121,15 +121,3 @@ The official documentation can be found on [the GitHub page](https://chinapandam
 <!-- TODO: remove WIP when finish recording -->
 * [(WIP) Video Tutorials](https://youtube.com/playlist?list=PLNz_PBu1QA-gzYg5BvyOO98q15u5Xve1L&si=8MWasKEckBzY-NRQ)
 * [Chicago Python User Group - Dec 14, 2023](https://youtu.be/8t1RdAKwr9w?si=TLgumBNXv9H8szSn)
-
-## Star History
-
-This project is maintained entirely in my spare time. If you like the project please consider starring the GitHub repository. It is the best way to keep me motivated and continue making the project better.
-
-<a href="https://www.star-history.com/?repos=chinapandaman%2FPyPDFForm&type=date&logscale=&legend=top-left">
- <picture>
-   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/chart?repos=chinapandaman/PyPDFForm&type=date&theme=dark&legend=top-left" />
-   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/chart?repos=chinapandaman/PyPDFForm&type=date&legend=top-left" />
-   <img alt="Star History Chart" src="https://api.star-history.com/chart?repos=chinapandaman/PyPDFForm&type=date&legend=top-left" />
- </picture>
-</a>

{pypdfform-5.3.0 → pypdfform-5.4.0}/README.md

@@ -72,15 +72,3 @@ The official documentation can be found on [the GitHub page](https://chinapandam
 <!-- TODO: remove WIP when finish recording -->
 * [(WIP) Video Tutorials](https://youtube.com/playlist?list=PLNz_PBu1QA-gzYg5BvyOO98q15u5Xve1L&si=8MWasKEckBzY-NRQ)
 * [Chicago Python User Group - Dec 14, 2023](https://youtu.be/8t1RdAKwr9w?si=TLgumBNXv9H8szSn)
-
-## Star History
-
-This project is maintained entirely in my spare time. If you like the project please consider starring the GitHub repository. It is the best way to keep me motivated and continue making the project better.
-
-<a href="https://www.star-history.com/?repos=chinapandaman%2FPyPDFForm&type=date&logscale=&legend=top-left">
- <picture>
-   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/chart?repos=chinapandaman/PyPDFForm&type=date&theme=dark&legend=top-left" />
-   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/chart?repos=chinapandaman/PyPDFForm&type=date&legend=top-left" />
-   <img alt="Star History Chart" src="https://api.star-history.com/chart?repos=chinapandaman/PyPDFForm&type=date&legend=top-left" />
- </picture>
-</a>