datacontract-cli 1.1.0__tar.gz → 1.1.1__tar.gz

{datacontract_cli-1.1.0 → datacontract_cli-1.1.1}/MANIFEST.in

@@ -1,4 +1,5 @@
 include datacontract/templates/style/output.css
+include datacontract/templates/excel/odcs-template.xlsx
 recursive-include datacontract/templates/ **/*.html
 recursive-include datacontract/schemas/ **/*.json **/*.yaml
 recursive-include datacontract/editor_assets/ *

{datacontract_cli-1.1.0/datacontract_cli.egg-info → datacontract_cli-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacontract-cli
-Version: 1.1.0
+Version: 1.1.1
 Summary: The datacontract CLI is an open source command-line tool for working with Data Contracts. It uses data contract YAML files to lint the data contract, connect to data sources and execute schema and quality tests, detect breaking changes, and export to different formats. The tool is written in Python. It can be used as a standalone CLI tool, in a CI/CD pipeline, or directly as a Python library.
 Author-email: Jochen Christ <jochen.christ@entropy-data.com>, Stefan Negele <stefan.negele@innoq.com>, Simon Harrer <simon.harrer@entropy-data.com>
 License-Expression: MIT
@@ -67,7 +67,7 @@ Requires-Dist: rich>=12.4.4; extra == "dataframe"
 Provides-Extra: databricks
 Requires-Dist: ibis-framework[databricks]<13.0.0,>=10.0.0; extra == "databricks"
 Requires-Dist: databricks-sql-connector<4.5.0,>=3.7.0; extra == "databricks"
-Requires-Dist: databricks-sdk<0.123.0; extra == "databricks"
+Requires-Dist: databricks-sdk<0.126.0; extra == "databricks"
 Requires-Dist: packaging<27.0,>=21.3; extra == "databricks"
 Provides-Extra: databricks-runtime
 Requires-Dist: datacontract-cli[databricks]; extra == "databricks-runtime"
@@ -139,6 +139,7 @@ Requires-Dist: httpx==0.28.1; extra == "dev"
 Requires-Dist: kafka-python; extra == "dev"
 Requires-Dist: minio==7.2.20; extra == "dev"
 Requires-Dist: moto==5.2.2; extra == "dev"
+Requires-Dist: openapi-spec-validator<0.10,>=0.7; extra == "dev"
 Requires-Dist: pandas>=2.1.0; extra == "dev"
 Requires-Dist: pre-commit<4.7.0,>=3.7.1; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
@@ -146,7 +147,7 @@ Requires-Dist: pytest-xdist; extra == "dev"
 Requires-Dist: pymssql==2.3.13; extra == "dev"
 Requires-Dist: psycopg2-binary<3.0,>=2.9; extra == "dev"
 Requires-Dist: mysql-connector-python<26.8.0,>=8.0.30; extra == "dev"
-Requires-Dist: ruff==0.16.1; extra == "dev"
+Requires-Dist: ruff==0.16.2; extra == "dev"
 Requires-Dist: testcontainers[kafka,minio,mssql,mysql,postgres]==4.15.0; extra == "dev"
 Requires-Dist: trino==0.338.0; extra == "dev"
 Dynamic: license-file
@@ -399,6 +400,8 @@ alias datacontract='docker run --rm -v "${PWD}:/home/datacontract" datacontract/
 
 _Note:_ The output of Docker command line messages is limited to 80 columns and may include line breaks. Don't pipe docker output to files if you want to export code. Use the `--output` option instead.
 
+Released images are signed with [cosign](https://docs.sigstore.dev/cosign/signing/overview/) keyless signing. See [Verifying the image](https://docs.datacontract.com/installation#verifying-the-image) to check a signature before you run it.
+
 
 
 ## Optional Dependencies (Extras)

{datacontract_cli-1.1.0 → datacontract_cli-1.1.1}/README.md

@@ -246,6 +246,8 @@ alias datacontract='docker run --rm -v "${PWD}:/home/datacontract" datacontract/
 
 _Note:_ The output of Docker command line messages is limited to 80 columns and may include line breaks. Don't pipe docker output to files if you want to export code. Use the `--output` option instead.
 
+Released images are signed with [cosign](https://docs.sigstore.dev/cosign/signing/overview/) keyless signing. See [Verifying the image](https://docs.datacontract.com/installation#verifying-the-image) to check a signature before you run it.
+
 
 
 ## Optional Dependencies (Extras)

{datacontract_cli-1.1.0 → datacontract_cli-1.1.1}/datacontract/api.py

@@ -2,21 +2,22 @@ import json
 import logging
 import os
 import tempfile
+from importlib import metadata
 from typing import Annotated, Optional
 
 import pydantic
-import typer
 import yaml
 from fastapi import Body, Depends, FastAPI, HTTPException, Query, Request, status
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import PlainTextResponse
 from fastapi.security.api_key import APIKeyHeader
-from pydantic import BaseModel, ValidationError
+from pydantic import BaseModel, Field, ValidationError
 
 from datacontract.config import Config, known_env_names
 from datacontract.data_contract import DataContract, ExportFormat
+from datacontract.model.changelog import ChangelogEntry
 from datacontract.model.exceptions import DataContractException
-from datacontract.model.run import Run
+from datacontract.model.run import Check, ResultEnum, Run
 
 DATA_CONTRACT_EXAMPLE_PAYLOAD = """apiVersion: v3.1.0
 kind: DataContract
@@ -225,40 +226,114 @@ def _require_schema_url(schema: str | None) -> str | None:
     return schema
 
 
+def _cli_version() -> str:
+    try:
+        return metadata.version("datacontract-cli")
+    except metadata.PackageNotFoundError:
+        return "0.0.0"
+
+
+API_DESCRIPTION = """
+The Data Contract CLI as a web server. Every endpoint takes an
+[ODCS](https://bitol-io.github.io/open-data-contract-standard/) data contract and runs one of the
+CLI commands against it, so anything `datacontract test|lint|export|changelog` can do on the command
+line can be done over HTTP.
+
+The data contract is the request body: `POST` it as `application/yaml` (or as a JSON string) —
+there is no contract storage, every request is self-contained.
+
+## Authentication
+
+Authentication is off unless the server was started with the environment variable
+`DATACONTRACT_CLI_API_KEY` set. When it is set, every endpoint requires the header `x-api-key` with
+that value, and answers `401` when the header is missing and `403` when it is wrong.
+
+Securing the API is strongly recommended: `POST /test` connects to your data sources, and test
+results may contain sensitive information.
+
+## Connecting to data sources
+
+`POST /test` needs credentials for the server described in the contract's `servers` section. Provide
+them either as environment variables when starting the server, or per request as `datacontract-*`
+headers, which are matched case-insensitively and map mechanically to the environment variable names
+(`datacontract-snowflake-password` sets `DATACONTRACT_SNOWFLAKE_PASSWORD` for that request only).
+Per-request headers are never written to the process environment, so one server can serve several
+tenants. Send them over HTTPS only.
+
+See [Configuration](https://docs.datacontract.com/configuration) for the full list of options.
+"""
+
 app = FastAPI(
     docs_url="/",
     title="Data Contract CLI API",
-    summary="You can use the API to test, export, and lint your data contracts.",
+    summary="Test, lint, export, and compare data contracts over HTTP.",
+    description=API_DESCRIPTION,
+    version=_cli_version(),
     license_info={
         "name": "MIT License",
         "identifier": "MIT",
     },
-    contact={"name": "Data Contract CLI", "url": "https://cli.datacontract.com/"},
+    contact={
+        "name": "Data Contract CLI",
+        "url": "https://docs.datacontract.com/",
+    },
+    # Relative, so the document works for any deployment. A second, absolute entry would
+    # show up as a target in the Swagger UI dropdown and invite sending contracts there.
+    servers=[{"url": "/", "description": "The server this document was loaded from"}],
     openapi_tags=[
         {
             "name": "test",
+            "description": "Run the schema and quality tests of a data contract against the actual data.",
             "externalDocs": {
                 "description": "Documentation",
-                "url": "https://cli.datacontract.com/#test",
+                "url": "https://docs.datacontract.com/testing/",
             },
         },
         {
             "name": "lint",
+            "description": "Validate that a data contract is syntactically correct and follows the standard.",
             "externalDocs": {
                 "description": "Documentation",
-                "url": "https://cli.datacontract.com/#lint",
+                "url": "https://docs.datacontract.com/commands/lint",
             },
         },
         {
             "name": "export",
+            "description": "Convert a data contract into another format, such as SQL DDL, Avro, or dbt.",
+            "externalDocs": {
+                "description": "Documentation",
+                "url": "https://docs.datacontract.com/exports/",
+            },
+        },
+        {
+            "name": "changelog",
+            "description": "Compare two versions of a data contract and list what changed.",
             "externalDocs": {
                 "description": "Documentation",
-                "url": "https://cli.datacontract.com/#export",
+                "url": "https://docs.datacontract.com/commands/changelog",
             },
         },
     ],
 )
 
+_fastapi_openapi = app.openapi
+
+
+def _openapi_with_external_docs() -> dict:
+    """Add the document-level `externalDocs`, which FastAPI has no constructor argument for."""
+    schema = _fastapi_openapi()
+    schema.setdefault(
+        "externalDocs",
+        {
+            "description": "Data Contract CLI documentation",
+            "url": "https://docs.datacontract.com/api",
+        },
+    )
+    return schema
+
+
+app.openapi = _openapi_with_external_docs
+
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -268,10 +343,57 @@ app.add_middleware(
 
 api_key_header = APIKeyHeader(
     name="x-api-key",
+    description="The secret the server was started with in the environment variable "
+    "`DATACONTRACT_CLI_API_KEY`. Only required if that variable is set.",
     auto_error=False,  # this makes authentication optional
 )
 
 
+class ErrorResponse(BaseModel):
+    """The body returned for a request that could not be handled."""
+
+    detail: str = Field(
+        description="A human-readable explanation of why the request failed.",
+        examples=["Missing API key. Use Header 'x-api-key' to provide the API key."],
+    )
+
+
+class RequestValidationErrorItem(BaseModel):
+    """A single violation found while validating the request itself."""
+
+    loc: list[str | int] = Field(description="The path to the offending part of the request.")
+    msg: str = Field(description="What is wrong with it.")
+    type: str = Field(description="The machine-readable error type.")
+
+
+class UnprocessableEntityResponse(BaseModel):
+    """The body returned for a request that is well-formed but cannot be processed."""
+
+    detail: str | list[RequestValidationErrorItem] = Field(
+        description="A message explaining why the request was rejected, or — when the request itself "
+        "failed validation — one entry per violation.",
+        examples=["The schema parameter must be an http:// or https:// URL."],
+    )
+
+
+AUTHENTICATION_RESPONSES: dict[int | str, dict] = {
+    401: {
+        "description": "The API key is missing (only when the server runs with DATACONTRACT_CLI_API_KEY set).",
+        "model": ErrorResponse,
+        "content": {
+            "application/json": {
+                "example": {"detail": "Missing API key. Use Header 'x-api-key' to provide the API key."}
+            }
+        },
+    },
+    403: {
+        "description": "The provided API key is not correct.",
+        "model": ErrorResponse,
+        "content": {"application/json": {"example": {"detail": "The provided API key is not correct."}}},
+    },
+}
+
+
 _CONFIG_HEADER_PREFIX = "datacontract-"
 
 
@@ -348,33 +470,40 @@ def check_api_key(api_key_header: str | None):
 @app.post(
     "/test",
     tags=["test"],
-    summary="Run data contract tests",
+    operation_id="testDataContract",
+    summary="Run the tests of a data contract",
     description="""
-              Run schema and quality tests. Data Contract CLI connects to the data sources configured in the server section.
-              This usually requires credentials to access the data sources.
-              Credentials can be provided via environment variables when running the web server, or per request
-              via datacontract-* headers (case-insensitive), which map to the environment variable names
-              (e.g. datacontract-snowflake-password sets DATACONTRACT_SNOWFLAKE_PASSWORD for this request only).
-              POST the data contract YAML as payload.
+Run the schema and quality tests of a data contract against the actual data. The Data Contract CLI
+connects to the data source described by the contract's `servers` section, so this usually requires
+credentials — set them as environment variables when starting the server, or send them per request
+as `datacontract-*` headers (see the API description).
+
+`POST` the data contract as `application/yaml`. The response is a test run with one check per
+executed test; `result` is `passed` only if every check passed. Note that a failed test is a
+`200 OK` with `"result": "failed"` — a non-2xx status means the request itself could not be
+handled. A contract that cannot be parsed is reported the same way, as a failed check.
             """,
+    response_description="The test run, with one check per executed test.",
     responses={
-        401: {
-            "description": "Unauthorized (when an environment variable DATACONTRACT_CLI_API_KEY is configured).",
+        **AUTHENTICATION_RESPONSES,
+        400: {
+            "description": "A `datacontract-*` header does not name a known configuration option, "
+            "or its value is not valid for that option.",
+            "model": ErrorResponse,
             "content": {
                 "application/json": {
-                    "examples": {
-                        "api_key_missing": {
-                            "summary": "API key Missing",
-                            "value": {"detail": "Missing API key. Use Header 'x-api-key' to provide the API key."},
-                        },
-                        "api_key_wrong": {
-                            "summary": "API key Wrong",
-                            "value": {"detail": "The provided API key is not correct."},
-                        },
+                    "example": {
+                        "detail": "Invalid datacontract-* configuration header: "
+                        "DATACONTRACT_SNOWFLAKE_LOGIN_TIMEOUT: input should be a valid integer"
                     }
                 }
             },
         },
+        422: {
+            "description": "`filter` and `filters` were both given, or `filters` is not a JSON object "
+            "mapping schema name to a SQL predicate.",
+            "model": UnprocessableEntityResponse,
+        },
     },
     response_model_exclude_none=True,
     response_model_exclude_unset=True,
@@ -442,11 +571,39 @@ async def test(
     ).test()
 
 
+class LintResponse(BaseModel):
+    """The outcome of validating a data contract against the schema."""
+
+    result: ResultEnum = Field(
+        description="`passed` if the data contract is valid, otherwise the most severe check result.",
+        examples=["passed"],
+    )
+    checks: list[Check] = Field(
+        description="One entry per validation performed. A valid contract yields a single passed check; "
+        "an invalid one yields a failed check per schema violation.",
+    )
+
+
 @app.post(
     "/lint",
     tags=["lint"],
-    summary="Validate that the datacontract.yaml is correctly formatted.",
-    description="""Validate that the datacontract.yaml is correctly formatted.""",
+    operation_id="lintDataContract",
+    summary="Validate that a data contract is correctly formatted",
+    description="""
+Validate that the data contract is syntactically correct and conforms to the Open Data Contract
+Standard. No data source is contacted, so no credentials are needed.
+
+An invalid contract is reported as a `200 OK` with `"result": "failed"` and one check per schema
+violation — not as an error status. A `schema` that is not an `http(s)` URL is rejected with `422`.
+            """,
+    response_description="The lint result, with one check per validation performed.",
+    responses={
+        **AUTHENTICATION_RESPONSES,
+        422: {
+            "description": "The `schema` parameter is not an `http(s)` URL.",
+            "model": UnprocessableEntityResponse,
+        },
+    },
 )
 async def lint(
     body: Annotated[
@@ -457,43 +614,81 @@ async def lint(
             examples=[DATA_CONTRACT_EXAMPLE_PAYLOAD],
         ),
     ],
+    api_key: Annotated[str | None, Depends(api_key_header)] = None,
     schema: Annotated[
         str | None,
         Query(
             examples=["https://datacontract.com/datacontract.schema.json"],
-            description="The schema to use for validation. This must be a URL.",
+            description="The JSON Schema to validate against, as an `http(s)` URL. "
+            "Defaults to the schema for the contract's `apiVersion`.",
         ),
     ] = None,
     all_errors: Annotated[
         bool,
         Query(description="Report all JSON Schema validation errors instead of only the first one."),
     ] = False,
-):
+) -> LintResponse:
+    check_api_key(api_key)
     data_contract = DataContract(
         data_contract_str=body, schema_location=_require_schema_url(schema), all_errors=all_errors
     )
     lint_result = data_contract.lint()
-    return {"result": lint_result.result, "checks": lint_result.checks}
+    return LintResponse(result=lint_result.result, checks=lint_result.checks)
 
 
 class ChangelogRequest(BaseModel):
-    v1: str = DATA_CONTRACT_EXAMPLE_PAYLOAD
-    v2: str = DATA_CONTRACT_EXAMPLE_PAYLOAD
+    """The two data contract versions to compare."""
+
+    v1: str = Field(
+        default=DATA_CONTRACT_EXAMPLE_PAYLOAD,
+        title="Source Data Contract YAML",
+        description="The data contract as it was before, as a YAML string.",
+    )
+    v2: str = Field(
+        default=DATA_CONTRACT_EXAMPLE_PAYLOAD,
+        title="Target Data Contract YAML",
+        description="The data contract as it is now, as a YAML string.",
+    )
+
+
+class ChangelogResponse(BaseModel):
+    """The differences between two versions of a data contract."""
+
+    summary: list[ChangelogEntry] = Field(
+        description="One entry per changed element, rolled up to the level a reader cares about "
+        "(a renamed property is one entry, not one per changed attribute). Values are omitted.",
+    )
+    entries: list[ChangelogEntry] = Field(
+        description="Every individual change, with the old and new value.",
+    )
 
 
 @app.post(
     "/changelog",
     tags=["changelog"],
-    summary="Show a changelog between two data contracts.",
+    operation_id="changelogBetweenDataContracts",
+    summary="Show a changelog between two data contracts",
     description="""
-        Compare two ODCS data contract YAMLs and return a changelog.
-        POST a JSON body with `v1` (source/before) and `v2` (target/after) as YAML strings.
+Compare two versions of an ODCS data contract and return what changed between them. Useful to
+decide whether a new version is a breaking change before publishing it.
+
+`POST` a JSON body with `v1` (before) and `v2` (after) as YAML strings. A contract that cannot be
+parsed is answered with `422`.
     """,
+    response_description="The changelog, as a rolled-up summary and the individual changes.",
+    responses={
+        **AUTHENTICATION_RESPONSES,
+        422: {
+            "description": "One of the two data contracts is not valid YAML or not a valid data contract.",
+            "model": UnprocessableEntityResponse,
+            "content": {"application/json": {"example": {"detail": "Invalid YAML: while parsing a block mapping"}}},
+        },
+    },
 )
 async def changelog_endpoint(
     body: ChangelogRequest,
     api_key: Annotated[str | None, Depends(api_key_header)] = None,
-):
+) -> ChangelogResponse:
     check_api_key(api_key)
 
     with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f1:
@@ -505,7 +700,7 @@ async def changelog_endpoint(
 
     try:
         result = DataContract(data_contract_file=v1_path).changelog(DataContract(data_contract_file=v2_path))
-        return {"summary": result.summary, "entries": result.entries}
+        return ChangelogResponse(summary=result.summary, entries=result.entries)
     except yaml.YAMLError as e:
         raise HTTPException(status_code=422, detail=f"Invalid YAML: {e}")
     except pydantic.ValidationError as e:
@@ -520,8 +715,53 @@ async def changelog_endpoint(
 @app.post(
     "/export",
     tags=["export"],
-    summary="Convert data contract to a specific format.",
+    operation_id="exportDataContract",
+    summary="Convert a data contract to another format",
+    description="""
+Convert a data contract into another format, such as SQL DDL, Avro, Protobuf, dbt, or HTML.
+
+The response is the converted document as `text/plain`; its actual syntax depends on the requested
+`format`. Some formats have extra parameters, marked with the format they apply to in their
+description.
+    """,
+    response_description="The data contract converted to the requested format.",
     response_class=PlainTextResponse,
+    # Spelled out rather than reusing the shared entries, because a route with a
+    # non-JSON response_class would have FastAPI document every declared model in
+    # that media type — while errors are always returned as JSON.
+    responses={
+        200: {
+            "description": "The data contract converted to the requested format.",
+            "content": {
+                "text/plain": {
+                    "schema": {"type": "string"},
+                    "example": "CREATE TABLE orders (\n  order_id UUID PRIMARY KEY,\n  order_total INTEGER NOT NULL\n);",
+                }
+            },
+        },
+        401: {
+            "description": AUTHENTICATION_RESPONSES[401]["description"],
+            "content": {
+                "application/json": {
+                    "schema": {"$ref": "#/components/schemas/ErrorResponse"},
+                    "example": {"detail": "Missing API key. Use Header 'x-api-key' to provide the API key."},
+                }
+            },
+        },
+        403: {
+            "description": AUTHENTICATION_RESPONSES[403]["description"],
+            "content": {
+                "application/json": {
+                    "schema": {"$ref": "#/components/schemas/ErrorResponse"},
+                    "example": {"detail": "The provided API key is not correct."},
+                }
+            },
+        },
+        422: {
+            "description": "The data contract could not be parsed, or is not a valid data contract.",
+            "content": {"application/json": {"schema": {"$ref": "#/components/schemas/UnprocessableEntityResponse"}}},
+        },
+    },
 )
 def export(
     body: Annotated[
@@ -532,7 +772,14 @@ def export(
             examples=[DATA_CONTRACT_EXAMPLE_PAYLOAD],
         ),
     ],
-    format: Annotated[ExportFormat, typer.Option(help="The export format.")],
+    format: Annotated[
+        ExportFormat,
+        Query(
+            description="The format to convert the data contract to.",
+            examples=["sql"],
+        ),
+    ],
+    api_key: Annotated[str | None, Depends(api_key_header)] = None,
     server: Annotated[
         str | None,
         Query(
@@ -546,24 +793,35 @@ def export(
             description="Use the key of the model in the data contract yaml file "
             "to refer to a model, e.g., `orders`, or `all` for all "
             "models (default).",
+            examples=["all"],
         ),
     ] = "all",
     rdf_base: Annotated[
         Optional[str],
-        typer.Option(help="[rdf] The base URI used to generate the RDF graph.", rich_help_panel="RDF Options"),
+        Query(
+            description="[rdf] The base URI used to generate the RDF graph.",
+            examples=["https://example.com/"],
+        ),
     ] = None,
     sql_server_type: Annotated[
         Optional[str],
         Query(
             description="[sql] The server type to determine the sql dialect. By default, it uses 'auto' to automatically detect the sql dialect via the specified servers in the data contract.",
+            examples=["postgres"],
         ),
     ] = None,
 ):
-    result = DataContract(data_contract_str=body, server=server).export(
-        export_format=format,
-        model=model,
-        rdf_base=rdf_base,
-        sql_server_type=sql_server_type,
-    )
-
-    return result
+    check_api_key(api_key)
+    try:
+        return DataContract(data_contract_str=body, server=server).export(
+            export_format=format,
+            model=model,
+            rdf_base=rdf_base,
+            sql_server_type=sql_server_type,
+        )
+    except yaml.YAMLError as e:
+        raise HTTPException(status_code=422, detail=f"Invalid YAML: {e}")
+    except pydantic.ValidationError as e:
+        raise HTTPException(status_code=422, detail=f"Invalid data contract: {e}")
+    except DataContractException as e:
+        raise HTTPException(status_code=422, detail=f"Data Contract Validation Failure: {e}")

{datacontract_cli-1.1.0 → datacontract_cli-1.1.1}/datacontract/command_api.py

@@ -46,7 +46,7 @@ def api(
     This is highly recommended, as data contract tests may be subject to SQL injections or leak sensitive information.
 
     To connect to servers (such as a Snowflake data source), set the credentials as environment variables as documented in
-    https://cli.datacontract.com/#test
+    https://docs.datacontract.com/configuration
 
     It is possible to run the API with extra arguments for `uvicorn.run()` as keyword arguments, e.g.:
     `datacontract api --port 1234 --root_path /datacontract`.

{datacontract_cli-1.1.0 → datacontract_cli-1.1.1}/datacontract/command_ci.py

@@ -61,6 +61,13 @@ def ci(
         OutputFormat,
         typer.Option(help="The target format for the test results. Accepted values: json, junit."),
     ] = None,
+    metadata_only: Annotated[
+        bool,
+        typer.Option(
+            help="Run only checks that read the schema (field presence and types). "
+            "Checks that read row values are skipped."
+        ),
+    ] = False,
     logs: Annotated[bool, typer.Option(help="Print logs")] = False,
     json_output: Annotated[bool, typer.Option("--json", help="Print test results as JSON to stdout.")] = False,
     fail_on: Annotated[
@@ -119,6 +126,7 @@ def ci(
             server=server,
             ssl_verification=ssl_verification,
             inline_references=inline_references,
+            metadata_only=metadata_only,
         ).test()
         if logs:
             _print_logs(run, out)

{datacontract_cli-1.1.0 → datacontract_cli-1.1.1}/datacontract/command_export.py

@@ -667,7 +667,7 @@ def export_excel(
     location: location_arg = "datacontract.yaml",
     template: Annotated[
         Optional[str],
-        typer.Option(help="Path or URL to a custom Excel template."),
+        typer.Option(help="Path or URL to a custom Excel template. Defaults to the bundled ODCS template."),
     ] = None,
     output: output_option = None,
     server: server_option = None,

{datacontract_cli-1.1.0 → datacontract_cli-1.1.1}/datacontract/command_import.py

@@ -416,6 +416,26 @@ def import_protobuf(
     _write_result(result, output)
 
 
+@import_app.command(
+    name="pydantic-model",
+    epilog="Example: datacontract import pydantic-model --source models.py --output datacontract.yaml",
+)
+def import_pydantic_model(
+    source: Annotated[Optional[str], typer.Option(help="Path to the Python file defining the Pydantic models.")] = None,
+    output: output_option = None,
+    schema: schema_option = None,
+    owner: owner_option = None,
+    id: id_option = None,
+    debug: debug_option = None,
+):
+    """Import a data contract from Pydantic models."""
+    enable_debug_logging(debug)
+    result = DataContract.import_from_source(
+        config=cli_config(), format="pydantic-model", source=source, schema=schema, owner=owner, id=id
+    )
+    _write_result(result, output)
+
+
 @import_app.command(
     name="spark",
     epilog="Example: datacontract import spark --tables orders,customers --output datacontract.yaml",