PyPI - datacontract-cli - Versions diffs - 0.11.9__tar.gz → 0.12.0__tar.gz - Mend

datacontract-cli 0.11.9tar.gz → 0.12.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (249) hide show

{datacontract_cli-0.11.9/datacontract_cli.egg-info → datacontract_cli-0.12.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacontract-cli
-Version: 0.11.9
+Version: 0.12.0
 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@innoq.com>, Stefan Negele <stefan.negele@innoq.com>, Simon Harrer <simon.harrer@innoq.com>
 License-Expression: MIT
@@ -186,7 +186,7 @@ Voilà, the CLI tested that the YAML itself is valid, all records comply with th
 We can also use the data contract metadata to export in many [formats](#format), e.g., to generate a SQL DDL:
 ```bash
-$ datacontract export --format sql https://datacontract.com/orders-v1.odcs.yaml
+$ datacontract export sql https://datacontract.com/orders-v1.odcs.yaml
 # returns:
 -- Data Contract: orders
@@ -209,7 +209,7 @@ CREATE TABLE line_items (
 Or generate an HTML export:
 ```bash
-$ datacontract export --format html --output orders-v1.odcs.html https://datacontract.com/orders-v1.odcs.yaml
+$ datacontract export html --output orders-v1.odcs.html https://datacontract.com/orders-v1.odcs.yaml
 ```
 [//]: # (which will create this [HTML export]&#40;https://datacontract.com/examples/orders-latest/datacontract.html&#41;.)
@@ -230,17 +230,17 @@ $ datacontract changelog v1.odcs.yaml v2.odcs.yaml
 # execute schema and quality checks (define credentials as environment variables)
 $ datacontract test odcs.yaml
-# export data contract as html (other formats: avro, dbt, dbt-sources, dbt-staging-sql, jsonschema, odcs, rdf, sql, sodacl, terraform, ...)
-$ datacontract export --format html datacontract.yaml --output odcs.html
+# export data contract as html (other formats: avro, dbt-models, dbt-sources, dbt-staging-sql, jsonschema, odcs, rdf, sql, sodacl, terraform, ...)
+$ datacontract export html datacontract.yaml --output odcs.html
 # import sql (other formats: avro, glue, bigquery, jsonschema, excel ...)
-$ datacontract import --format sql --source my-ddl.sql --dialect postgres --output odcs.yaml
+$ datacontract import sql --source my-ddl.sql --dialect postgres --output odcs.yaml
 # import from Excel template
-$ datacontract import --format excel --source odcs.xlsx --output odcs.yaml
+$ datacontract import excel --source odcs.xlsx --output odcs.yaml
 # export to Excel template
-$ datacontract export --format excel --output odcs.xlsx odcs.yaml
+$ datacontract export excel --output odcs.xlsx odcs.yaml
 ```
 ## Programmatic (Python)
@@ -386,51 +386,51 @@ Commands
  Create an empty data contract.
 ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮
 │   location      [LOCATION]  The location of the data contract file to create.                    │
 │                             [default: datacontract.yaml]                                         │
 ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
 ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮
-│ --template                       TEXT  URL of a template or data contract [default: None]        │
+│ --template                       TEXT  URL of a template or data contract                        │
 │ --overwrite    --no-overwrite          Replace the existing datacontract.yaml                    │
 │                                        [default: no-overwrite]                                   │
-│ --debug        --no-debug              Enable debug logging [default: no-debug]                  │
+│ --debug        --no-debug              Enable debug logging                                      │
 │ --help                                 Show this message and exit.                               │
 ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+ Example: datacontract init datacontract.yaml
 ```
 ### lint
 ```
- Usage: datacontract lint [OPTIONS] [LOCATION]
- Validate that the datacontract.yaml is correctly formatted.
-╭─ Arguments ──────────────────────────────────────────────────────────────────╮
-│   location      [LOCATION]  The location (url or path) of the data contract  │
-│                             yaml.                                            │
-│                             [default: datacontract.yaml]                     │
-╰──────────────────────────────────────────────────────────────────────────────╯
-╭─ Options ────────────────────────────────────────────────────────────────────╮
-│ --schema                         TEXT          The location (url or path) of │
-│                                                the ODCS JSON Schema          │
-│ --output                         PATH          Specify the file path where   │
-│                                                the test results should be    │
-│                                                written to (e.g.,             │
-│                                                './test-results/TEST-datacon… │
-│                                                If no path is provided, the   │
-│                                                output will be printed to     │
-│                                                stdout.                       │
-│ --output-format                  [json|junit]  The target format for the     │
-│                                                test results.                 │
-│ --all-errors                                   Report all JSON Schema        │
-│                                                validation errors instead of  │
-│                                                stopping after the first one. │
-│ --debug            --no-debug                  Enable debug logging          │
-│ --help                                         Show this message and exit.   │
-╰──────────────────────────────────────────────────────────────────────────────╯
+ Usage: datacontract lint [OPTIONS] [LOCATION]
+ Validate that the datacontract.yaml is correctly formatted.
+╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮
+│   location      [LOCATION]  The location (url or path) of the data contract yaml.                │
+│                             [default: datacontract.yaml]                                         │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮
+│ --json-schema                    TEXT          The location (url or path) of the ODCS JSON       │
+│                                                Schema                                            │
+│ --output                         PATH          Specify the file path where the test results      │
+│                                                should be written to (e.g.,                       │
+│                                                './test-results/TEST-datacontract.xml'). If no    │
+│                                                path is provided, the output will be printed to   │
+│                                                stdout.                                           │
+│ --output-format                  [json|junit]  The target format for the test results.           │
+│ --all-errors                                   Report all JSON Schema validation errors instead  │
+│                                                of stopping after the first one.                  │
+│ --debug            --no-debug                  Enable debug logging                              │
+│ --help                                         Show this message and exit.                       │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+ Example: datacontract lint datacontract.yaml
 ```
@@ -446,10 +446,9 @@ Commands
 │ *    v2      TEXT  The location (path) of the target (after) data contract YAML. [required]      │
 ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
 ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮
-│ --debug     --no-debug                 Enable debug logging                                      │
-│ --help                                 Show this message and exit.                               │
+│ --debug    --no-debug      Enable debug logging                                                  │
+│ --help                     Show this message and exit.                                           │
 ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
 ```
 ```bash
@@ -459,61 +458,61 @@ $ datacontract changelog v1.odcs.yaml v2.odcs.yaml
 ### test
 ```
- Usage: datacontract test [OPTIONS] [LOCATION]
+ Usage: datacontract test [OPTIONS] [LOCATION]
  Run schema and quality tests on configured servers.
 ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮
 │   location      [LOCATION]  The location (url or path) of the data contract yaml.                │
 │                             [default: datacontract.yaml]                                         │
 ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
 ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮
-│ --schema                                               TEXT     The location (url or path) of    │
-│                                                                 the ODCS JSON Schema             │
-│                                                                 [default: None]                  │
-│ --server                                               TEXT     The server configuration to run  │
-│                                                                 the schema and quality tests.    │
-│                                                                 Use the key of the server object │
-│                                                                 in the data contract yaml file   │
-│                                                                 to refer to a server, e.g.,      │
-│                                                                 `production`, or `all` for all   │
-│                                                                 servers (default).               │
-│                                                                 [default: all]                   │
-│ --schema-name                                          TEXT     The name of the schema to test,  │
-│                                                                 e.g., `orders`, or `all` for     │
-│                                                                 all schemas (default).           │
-│                                                                 [default: all]                   │
-│ --checks                                               TEXT     Comma-separated list of check    │
-│                                                                 categories to run. Available     │
-│                                                                 categories: schema, quality,     │
-│                                                                 servicelevel, custom. Omit to    │
-│                                                                 enable all.                      │
-│                                                                 [default: None]                  │
-│ --publish-test-results    --no-publish-test-results             Deprecated. Use publish          │
-│                                                                 parameter. Publish the results   │
-│                                                                 after the test                   │
-│                                                                 [default:                        │
-│                                                                 no-publish-test-results]         │
-│ --publish                                              TEXT     The url to publish the results   │
-│                                                                 after the test.                  │
-│                                                                 [default: None]                  │
-│ --output                                               PATH     Specify the file path where the  │
-│                                                                 test results should be written   │
-│                                                                 to (e.g.,                        │
-│                                                                 './test-results/TEST-datacontra… │
-│                                                                 [default: None]                  │
-│ --output-format                                        [junit]  The target format for the test   │
-│                                                                 results.                         │
-│                                                                 [default: None]                  │
-│ --logs                    --no-logs                             Print logs [default: no-logs]    │
-│ --ssl-verification        --no-ssl-verification                 SSL verification when publishing │
-│                                                                 the data contract.               │
-│                                                                 [default: ssl-verification]      │
-│ --debug                   --no-debug                            Enable debug logging             │
-│                                                                 [default: no-debug]              │
-│ --help                                                          Show this message and exit.      │
+│ --json-schema                                          TEXT          The location (url or path)  │
+│                                                                      of the ODCS JSON Schema     │
+│ --server                                               TEXT          The server configuration to │
+│                                                                      run the schema and quality  │
+│                                                                      tests. Use the key of the   │
+│                                                                      server object in the data   │
+│                                                                      contract yaml file to refer │
+│                                                                      to a server, e.g.,          │
+│                                                                      `production`, or `all` for  │
+│                                                                      all servers (default).      │
+│                                                                      [default: all]              │
+│ --schema-name                                          TEXT          Which schema to test, e.g., │
+│                                                                      `orders`, or `all` for all  │
+│                                                                      schemas (default).          │
+│                                                                      [default: all]              │
+│ --publish-test-results    --no-publish-test-results                  Deprecated. Use publish     │
+│                                                                      parameter. Publish the      │
+│                                                                      results after the test      │
+│                                                                      [default:                   │
+│                                                                      no-publish-test-results]    │
+│ --publish                                              TEXT          The url to publish the      │
+│                                                                      results after the test.     │
+│ --output                                               PATH          Specify the file path where │
+│                                                                      the test results should be  │
+│                                                                      written to (e.g.,           │
+│                                                                      './test-results/TEST-datac… │
+│ --output-format                                        [json|junit]  The target format for the   │
+│                                                                      test results.               │
+│ --checks                                               TEXT          Comma-separated list of     │
+│                                                                      check categories to run     │
+│                                                                      (available: schema,         │
+│                                                                      quality, servicelevel,      │
+│                                                                      custom). Omit to enable     │
+│                                                                      all.                        │
+│ --logs                    --no-logs                                  Print logs                  │
+│                                                                      [default: no-logs]          │
+│ --ssl-verification        --no-ssl-verification                      SSL verification when       │
+│                                                                      publishing the data         │
+│                                                                      contract.                   │
+│                                                                      [default: ssl-verification] │
+│ --debug                   --no-debug                                 Enable debug logging        │
+│ --help                                                               Show this message and exit. │
 ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+ Example: datacontract test datacontract.yaml --server production
 ```
@@ -1224,65 +1223,54 @@ models:
 ### ci
 ```
- Usage: datacontract ci [OPTIONS] [LOCATIONS]...
- Run tests for CI/CD pipelines. Emits GitHub Actions annotations and step
- summary.
-╭─ Arguments ──────────────────────────────────────────────────────────────────╮
-│   locations      [LOCATIONS]...  The location(s) (url or path) of the data   │
-│                                  contract yaml file(s).                      │
-╰──────────────────────────────────────────────────────────────────────────────╯
-╭─ Options ────────────────────────────────────────────────────────────────────╮
-│ --schema                                   TEXT          The location (url   │
-│                                                          or path) of the     │
-│                                                          ODCS JSON Schema    │
-│ --server                                   TEXT          The server          │
-│                                                          configuration to    │
-│                                                          run the schema and  │
-│                                                          quality tests. Use  │
-│                                                          the key of the      │
-│                                                          server object in    │
-│                                                          the data contract   │
-│                                                          yaml file to refer  │
-│                                                          to a server, e.g.,  │
-│                                                          `production`, or    │
-│                                                          `all` for all       │
-│                                                          servers (default).  │
-│                                                          [default: all]      │
-│ --publish                                  TEXT          The url to publish  │
-│                                                          the results after   │
-│                                                          the test.           │
-│ --output                                   PATH          Specify the file    │
-│                                                          path where the test │
-│                                                          results should be   │
-│                                                          written to (e.g.,   │
-│                                                          './test-results/TE… │
-│ --output-format                            [json|junit]  The target format   │
-│                                                          for the test        │
-│                                                          results.            │
-│ --logs                --no-logs                          Print logs          │
-│                                                          [default: no-logs]  │
-│ --json                --no-json                          Print test results  │
-│                                                          as JSON to stdout.  │
-│                                                          [default: no-json]  │
-│ --fail-on                                  TEXT          Minimum severity    │
-│                                                          that causes a       │
-│                                                          non-zero exit code: │
-│                                                          'warning', 'error', │
-│                                                          or 'never'.         │
-│                                                          [default: error]    │
-│ --ssl-verification    --no-ssl-verific…                  SSL verification    │
-│                                                          when publishing the │
-│                                                          data contract.      │
-│                                                          [default:           │
-│                                                          ssl-verification]   │
-│ --debug               --no-debug                         Enable debug        │
-│                                                          logging             │
-│ --help                                                   Show this message   │
-│                                                          and exit.           │
-╰──────────────────────────────────────────────────────────────────────────────╯
+ Usage: datacontract ci [OPTIONS] [LOCATIONS]...
+ Run tests for CI/CD pipelines. Emits GitHub Actions annotations and step summary.
+╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮
+│   locations      [LOCATIONS]...  The location(s) (url or path) of the data contract yaml         │
+│                                  file(s).                                                        │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮
+│ --json-schema                                  TEXT                   The location (url or path) │
+│                                                                       of the ODCS JSON Schema    │
+│ --server                                       TEXT                   The server configuration   │
+│                                                                       to run the schema and      │
+│                                                                       quality tests. Use the key │
+│                                                                       of the server object in    │
+│                                                                       the data contract yaml     │
+│                                                                       file to refer to a server, │
+│                                                                       e.g., `production`, or     │
+│                                                                       `all` for all servers      │
+│                                                                       (default).                 │
+│                                                                       [default: all]             │
+│ --publish                                      TEXT                   The url to publish the     │
+│                                                                       results after the test.    │
+│ --output                                       PATH                   Specify the file path      │
+│                                                                       where the test results     │
+│                                                                       should be written to       │
+│                                                                       (e.g.,                     │
+│                                                                       './test-results/TEST-data… │
+│ --output-format                                [json|junit]           The target format for the  │
+│                                                                       test results.              │
+│ --logs                --no-logs                                       Print logs                 │
+│                                                                       [default: no-logs]         │
+│ --json                                                                Print test results as JSON │
+│                                                                       to stdout.                 │
+│ --fail-on                                      [warning|error|never]  Minimum severity that      │
+│                                                                       causes a non-zero exit     │
+│                                                                       code.                      │
+│                                                                       [default: error]           │
+│ --ssl-verification    --no-ssl-verification                           SSL verification when      │
+│                                                                       publishing the data        │
+│                                                                       contract.                  │
+│                                                                       [default:                  │
+│                                                                       ssl-verification]          │
+│ --debug               --no-debug                                      Enable debug logging       │
+│ --help                                                                Show this message and      │
+│                                                                       exit.                      │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
 ```
@@ -1367,126 +1355,90 @@ steps:
 ### export
 ```
- Usage: datacontract export [OPTIONS] [LOCATION]
- Convert data contract to a specific format. Saves to file specified by `output` option if present,
- otherwise prints to stdout.
+ Usage: datacontract export [OPTIONS] COMMAND [ARGS]...
+ Convert a data contract to a target format.
-╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮
-│   location      [LOCATION]  The location (url or path) of the data contract yaml.                │
-│                             [default: datacontract.yaml]                                         │
-╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
 ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮
-│ *  --format                       [jsonschema|pydantic-model|sod  The export format.             │
-│                                   acl|dbt|dbt-sources|dbt-stagin  [default: None]                │
-│                                   g-sql|odcs|rdf|avro|protobuf|g  [required]                     │
-│                                   reat-expectations|avro-idl|sql                                 │
-│                                   |sql-query|mermaid|html|go|big                                 │
-│                                   query|dbml|spark|sqlalchemy|da                                 │
-│                                   ta-caterer|dcs|markdown|iceber                                 │
-│                                   g|custom|excel|dqx]                                            │
-│    --output                       PATH                            Specify the file path where    │
-│                                                                   the exported data will be      │
-│                                                                   saved. If no path is provided, │
-│                                                                   the output will be printed to  │
-│                                                                   stdout.                        │
-│                                                                   [default: None]                │
-│    --server                       TEXT                            The server name to export.     │
-│                                                                   [default: None]                │
-│    --schema-name                  TEXT                            The name of the schema to      │
-│                                                                   export, e.g., `orders`, or     │
-│                                                                   `all` for all schemas          │
-│                                                                   (default).                     │
-│                                                                   [default: all]                 │
-│    --schema                       TEXT                            The location (url or path) of  │
-│                                                                   the ODCS JSON Schema           │
-│                                                                   [default: None]                │
-│    --engine                       TEXT                            [engine] The engine used for   │
-│                                                                   great expection run.           │
-│                                                                   [default: None]                │
-│    --template                     PATH                            The file path or URL of a      │
-│                                                                   template. For Excel format:    │
-│                                                                   path/URL to custom Excel       │
-│                                                                   template. For custom format:   │
-│                                                                   path to Jinja template.        │
-│                                                                   [default: None]                │
-│    --debug          --no-debug                                    Enable debug logging           │
-│                                                                   [default: no-debug]            │
-│    --help                                                         Show this message and exit.    │
+│ --help          Show this message and exit.                                                      │
 ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
-╭─ RDF Options ────────────────────────────────────────────────────────────────────────────────────╮
-│ --rdf-base        TEXT  [rdf] The base URI used to generate the RDF graph. [default: None]       │
-╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
-╭─ SQL Options ────────────────────────────────────────────────────────────────────────────────────╮
-│ --sql-server-type        TEXT  [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. Accepted values: auto,    │
-│                                snowflake, postgres, mysql, databricks, sqlserver, bigquery,      │
-│                                trino, oracle. [default: auto]                                    │
+╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────╮
+│ sql                 Export a data contract to SQL DDL.                                           │
+│ sql-query           Export a data contract to a SQL query.                                       │
+│ dbt-models          Export a data contract to dbt model schema YAML.                             │
+│ dbt-sources         Export a data contract to dbt sources YAML.                                  │
+│ dbt-staging-sql     Export a data contract to a dbt staging SQL file.                            │
+│ avro                Export a data contract to Avro schema.                                       │
+│ avro-idl            Export a data contract to Avro IDL.                                          │
+│ jsonschema          Export a data contract to JSON Schema.                                       │
+│ pydantic-model      Export a data contract to a Pydantic model.                                  │
+│ protobuf            Export a data contract to Protobuf schema.                                   │
+│ odcs                Export a data contract to ODCS format.                                       │
+│ rdf                 Export a data contract to RDF.                                               │
+│ html                Export a data contract to HTML.                                              │
+│ markdown            Export a data contract to Markdown.                                          │
+│ mermaid             Export a data contract to Mermaid diagram.                                   │
+│ bigquery            Export a data contract to BigQuery schema.                                   │
+│ dbml                Export a data contract to DBML.                                              │
+│ go                  Export a data contract to Go structs.                                        │
+│ spark               Export a data contract to Spark schema.                                      │
+│ sqlalchemy          Export a data contract to SQLAlchemy models.                                 │
+│ iceberg             Export a data contract to Iceberg schema.                                    │
+│ sodacl              Export a data contract to SodaCL checks.                                     │
+│ great-expectations  Export a data contract to Great Expectations suite.                          │
+│ data-caterer        Export a data contract to Data Caterer format.                               │
+│ dcs                 Export a data contract to DCS format.                                        │
+│ dqx                 Export a data contract to DQX format.                                        │
+│ excel               Export a data contract to Excel.                                             │
+│ custom              Export a data contract using a custom Jinja template.                        │
 ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+ Example: datacontract export html datacontract.yaml --output datacontract.html
+ For SQL dialects (postgres, mysql, snowflake, databricks, sqlserver, trino, oracle), use
+ `datacontract export sql --dialect <dialect>`.
 ```
+Run `datacontract export <format> --help` to see the format-specific options (e.g. `datacontract export sql --help`). If you are missing a format, please [create an issue on GitHub](https://github.com/datacontract/datacontract-cli/issues).
+#### Examples
 ```bash
 # Example export data contract as HTML
-datacontract export --format html --output datacontract.html
-```
-Available export options:
-| Type                 | Description                                             | Status  |
-|----------------------|---------------------------------------------------------|---------|
-| `html`               | Export to HTML                                          | ✅       |
-| `jsonschema`         | Export to JSON Schema                                   | ✅       |
-| `odcs`               | Export to Open Data Contract Standard (ODCS) V3         | ✅       |
-| `sodacl`             | Export to SodaCL quality checks in YAML format          | ✅       |
-| `dbt`                | Export to dbt models in YAML format                     | ✅       |
-| `dbt-sources`        | Export to dbt sources in YAML format                    | ✅       |
-| `dbt-staging-sql`    | Export to dbt staging SQL models                        | ✅       |
-| `rdf`                | Export data contract to RDF representation in N3 format | ✅       |
-| `avro`               | Export to AVRO models                                   | ✅       |
-| `protobuf`           | Export to Protobuf                                      | ✅       |
-| `terraform`          | Export to terraform resources                           | ✅       |
-| `sql`                | Export to SQL DDL                                       | ✅       |
-| `sql-query`          | Export to SQL Query                                     | ✅       |
-| `great-expectations` | Export to Great Expectations Suites in JSON Format      | ✅       |
-| `bigquery`           | Export to BigQuery Schemas                              | ✅       |
-| `go`                 | Export to Go types                                      | ✅       |
-| `pydantic-model`     | Export to pydantic models                               | ✅       |
-| `DBML`               | Export to a DBML Diagram description                    | ✅       |
-| `spark`              | Export to a Spark StructType                            | ✅       |
-| `sqlalchemy`         | Export to SQLAlchemy Models                             | ✅       |
-| `data-caterer`       | Export to Data Caterer in YAML format                   | ✅       |
-| `dcs`                | Export to Data Contract Specification in YAML format    | ✅       |
-| `markdown`           | Export to Markdown                                      | ✅       |
-| `iceberg`            | Export to an Iceberg JSON Schema Definition             | partial |
-| `excel`              | Export to ODCS Excel Template                           | ✅       |
-| `custom`             | Export to Custom format with Jinja                      | ✅       |
-| `dqx`                | Export to DQX in YAML format                            | ✅       |
-| Missing something?   | Please create an issue on GitHub                        | TBD     |
-#### SQL
+datacontract export html --output datacontract.html
+```
+<details markdown="1">
+<summary><strong>SQL</strong></summary>
 The `export` function converts a given data contract into a SQL data definition language (DDL).
 ```shell
-datacontract export datacontract.yaml --format sql --output output.sql
+datacontract export sql datacontract.yaml --output output.sql
 ```
-If using Databricks, and an error is thrown when trying to deploy the SQL DDLs with `variant` columns set the following properties.
+The SQL dialect is determined from the `servers` block in the data contract (e.g. `type: postgres`, `type: snowflake`). Alternatively, pass it explicitly:
+```shell
+datacontract export sql datacontract.yaml --dialect postgres --output output.sql
+```
+If using Databricks and an error is thrown when deploying SQL DDLs with `variant` columns, set the following property.
 ```shell
 spark.conf.set(“spark.databricks.delta.schema.typeCheck.enabled”, “false”)
 ```
-#### Great Expectations
+</details>
+<details markdown="1">
+<summary><strong>Great Expectations</strong></summary>
 The `export` function transforms a specified data contract into a comprehensive Great Expectations JSON suite.
 If the contract includes multiple models, you need to specify the names of the schema/models you wish to export.
 ```shell
-datacontract export datacontract.yaml --format great-expectations --model orders
+datacontract export great-expectations datacontract.yaml --schema-name orders
 ```
 The export creates a list of expectations by utilizing:
@@ -1509,13 +1461,16 @@ To further customize the export, the following optional arguments are available:
   Providing `sql_server_type` ensures that the appropriate SQL dialect and connection settings are applied during the expectation validation.
-#### RDF
+</details>
+<details markdown="1">
+<summary><strong>RDF</strong></summary>
 The `export` function converts a given data contract into a RDF representation. You have the option to
 add a base_url which will be used as the default prefix to resolve relative IRIs inside the document.
 ```shell
-datacontract export --format rdf --rdf-base https://www.example.com/ datacontract.yaml
+datacontract export rdf --base https://www.example.com/ datacontract.yaml
 ```
 The data contract is mapped onto the following concepts of a yet to be defined Data Contract
@@ -1533,24 +1488,36 @@ Having the data contract inside an RDF Graph gives us access the following use c
 - Apply graph algorithms on multiple data contracts (Find similar data contracts, find "gatekeeper"
 data products, find the true domain owner of a field attribute)
-#### DBML
+</details>
+<details markdown="1">
+<summary><strong>DBML</strong></summary>
 The export function converts the logical data types of the datacontract into the specific ones of a concrete Database
 if a server is selected via the `--server` option (based on the `type` of that server). If no server is selected, the
 logical data types are exported.
-#### DBT & DBT-SOURCES
+</details>
+<details markdown="1">
+<summary><strong>DBT & DBT-SOURCES</strong></summary>
 The export function converts the datacontract to dbt models in YAML format, with support for SQL dialects.
 If a server is selected via the `--server` option (based on the `type` of that server) then the DBT column `data_types` match the expected data types of the server.
 If no server is selected, then it defaults to `snowflake`.
-#### Spark
+</details>
+<details markdown="1">
+<summary><strong>Spark</strong></summary>
 The export function converts the data contract specification into a StructType Spark schema. The returned value is a Python code picture of the model schemas.
 Spark DataFrame schema is defined as StructType. For more details about Spark Data Types please see [the spark documentation](https://spark.apache.org/docs/latest/sql-ref-datatypes.html)
-#### Avro
+</details>
+<details markdown="1">
+<summary><strong>Avro</strong></summary>
 The export function converts the data contract specification into an avro schema. It supports specifying custom avro properties for logicalTypes and default values.
@@ -1562,7 +1529,7 @@ To specify custom Avro properties in your data contract, you can define them wit
 >NOTE: At this moment, we just support [logicalType](https://avro.apache.org/docs/1.11.0/spec.html#Logical+Types) and [default](https://avro.apache.org/docs/1.11.0/spec.htm)
-#### Example Configuration
+##### Example Configuration
 ```yaml
 models:
@@ -1578,7 +1545,7 @@ models:
           avroDefault: 1672534861000000
 ```
-#### Explanation
+##### Explanation
 - **models**: The top-level key that contains different models (tables or objects) in your data contract.
 - **orders**: A specific model name. Replace this with the name of your model.
@@ -1592,29 +1559,35 @@ models:
     - **avroLogicalType**: Specifies the logical type of the field in Avro. In this example, it is `local-timestamp-micros`.
     - **avroDefault**: Specifies the default value for the field in Avro. In this example, it is 1672534861000000 which corresponds to ` 2023-01-01 01:01:01 UTC`.
-#### Data Caterer
+</details>
+<details markdown="1">
+<summary><strong>Data Caterer</strong></summary>
 The export function converts the data contract to a data generation task in YAML format that can be
 ingested by [Data Caterer](https://github.com/data-catering/data-caterer). This gives you the
 ability to generate production-like data in any environment based off your data contract.
 ```shell
-datacontract export datacontract.yaml --format data-caterer --model orders
+datacontract export data-caterer datacontract.yaml --schema-name orders
 ```
 You can further customise the way data is generated via adding
 [additional metadata in the YAML](https://data.catering/setup/generator/data-generator/)
 to suit your needs.
-#### Iceberg
+</details>
+<details markdown="1">
+<summary><strong>Iceberg</strong></summary>
 Exports to an [Iceberg Table Json Schema Definition](https://iceberg.apache.org/spec/#appendix-c-json-serialization).
-This export only supports a single model export at a time because Iceberg's schema definition is for a single table and the exporter maps 1 model to 1 table, use the `--model` flag
+This export only supports a single model export at a time because Iceberg's schema definition is for a single table and the exporter maps 1 model to 1 table, use the `--schema-name` flag
 to limit your contract export to a single model.
 ```bash
- $ datacontract export --format iceberg --model orders https://datacontract.com/examples/orders-latest/datacontract.yaml --output /tmp/orders_iceberg.json
+ $ datacontract export iceberg --schema-name orders https://datacontract.com/examples/orders-latest/datacontract.yaml --output /tmp/orders_iceberg.json
  $ cat /tmp/orders_iceberg.json | jq '.'
 {
@@ -1664,29 +1637,34 @@ to limit your contract export to a single model.
 }
 ```
-#### Custom
+</details>
+<details markdown="1">
+<summary><strong>Custom</strong></summary>
 The export function converts the data contract specification into the custom format with Jinja. You can specify the path to a Jinja template with the `--template` argument, allowing you to output files in any format.
 ```shell
-datacontract export --format custom --template template.txt datacontract.yaml
+datacontract export custom --template template.txt datacontract.yaml
 ```
 ##### Jinja templates & variables
-You can directly use the Data Contract Specification as template variables.
+You can directly use the ODCS (Open Data Contract Standard) object as a template variable. `data_contract` is an `OpenDataContractStandard` instance; top-level fields include `name`, `id`, `version`, `schema_` (the list of schemas), `servers`, `team`, etc.
 {% raw %}
 ```shell
 $ cat template.txt
-title: {{ data_contract.info.title }}
-models:
-{%- for model_name, model in data_contract.models.items() %}
-  - name: {{ model.name }}
+title: {{ data_contract.name }}
+schemas:
+{%- for schema in data_contract.schema_ %}
+  - name: {{ schema.name }}
 {%- endfor %}
-$ datacontract export --format custom --template template.txt datacontract.yaml
+$ datacontract export custom --template template.txt datacontract.yaml
 title: Orders Latest
+schemas:
+  - name: orders
 ```
 {% endraw %}
@@ -1716,7 +1694,7 @@ Below is an example of a dbt staging layer that converts a field of `type: times
   {% endraw %}
 - export command
   ```shell
-  datacontract export datacontract.odcs.yaml --format custom --template template.sql --schema-name orders
+  datacontract export custom datacontract.odcs.yaml --template template.sql --schema-name orders
   ```
 - `output.sql`
   {% raw %}
@@ -1732,12 +1710,15 @@ Below is an example of a dbt staging layer that converts a field of `type: times
   ```
   {% endraw %}
-#### ODCS Excel Template
+</details>
+<details markdown="1">
+<summary><strong>ODCS Excel Template</strong></summary>
 The `export` function converts a data contract into an ODCS (Open Data Contract Standard) Excel template. This creates a user-friendly Excel spreadsheet that can be used for authoring, sharing, and managing data contracts using the familiar Excel interface.
 ```shell
-datacontract export --format excel --output datacontract.xlsx datacontract.yaml
+datacontract export excel --output datacontract.xlsx datacontract.yaml
 ```
 The Excel format enables:
@@ -1748,135 +1729,57 @@ The Excel format enables:
 For more information about the Excel template structure, visit the [ODCS Excel Template repository](https://github.com/datacontract/open-data-contract-standard-excel-template).
+</details>
 ### import
 ```
- Usage: datacontract import [OPTIONS]
- Create a data contract from the given source location. Saves to file specified by `output` option
- if present, otherwise prints to stdout.
+ Usage: datacontract import [OPTIONS] COMMAND [ARGS]...
+ Create a data contract from a source format.
 ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮
-│ *  --format                                 [sql|avro|dbt|dbml|glue|  The format of the source   │
-│                                             jsonschema|json|bigquery  file.                      │
-│                                             |odcs|unity|spark|iceber  [default: None]            │
-│                                             g|parquet|csv|protobuf|e  [required]                 │
-│                                             xcel]                                                │
-│    --output                                 PATH                      Specify the file path      │
-│                                                                       where the Data Contract    │
-│                                                                       will be saved. If no path  │
-│                                                                       is provided, the output    │
-│                                                                       will be printed to stdout. │
-│                                                                       [default: None]            │
-│    --source                                 TEXT                      The path to the file that  │
-│                                                                       should be imported.        │
-│                                                                       [default: None]            │
-│    --dialect                                TEXT                      The SQL dialect.           │
-│                                                                       Accepted values: postgres, │
-│                                                                       tsql, bigquery, snowflake, │
-│                                                                       databricks, spark, duckdb. │
-│                                                                       [default: None]            │
-│    --glue-table                             TEXT                      List of table ids to       │
-│                                                                       import from the Glue       │
-│                                                                       Database (repeat for       │
-│                                                                       multiple table ids, leave  │
-│                                                                       empty for all tables in    │
-│                                                                       the dataset).              │
-│                                                                       [default: None]            │
-│    --bigquery-project                       TEXT                      The bigquery project id.   │
-│                                                                       [default: None]            │
-│    --bigquery-dataset                       TEXT                      The bigquery dataset id.   │
-│                                                                       [default: None]            │
-│    --bigquery-table                         TEXT                      List of table ids to       │
-│                                                                       import from the bigquery   │
-│                                                                       API (repeat for multiple   │
-│                                                                       table ids, leave empty for │
-│                                                                       all tables in the          │
-│                                                                       dataset).                  │
-│                                                                       [default: None]            │
-│    --unity-table-full-name                  TEXT                      Full name of a table in    │
-│                                                                       the unity catalog          │
-│                                                                       [default: None]            │
-│    --dbt-model                              TEXT                      List of models names to    │
-│                                                                       import from the dbt        │
-│                                                                       manifest file (repeat for  │
-│                                                                       multiple models names,     │
-│                                                                       leave empty for all models │
-│                                                                       in the dataset).           │
-│                                                                       [default: None]            │
-│    --dbml-schema                            TEXT                      List of schema names to    │
-│                                                                       import from the DBML file  │
-│                                                                       (repeat for multiple       │
-│                                                                       schema names, leave empty  │
-│                                                                       for all tables in the      │
-│                                                                       file).                     │
-│                                                                       [default: None]            │
-│    --dbml-table                             TEXT                      List of table names to     │
-│                                                                       import from the DBML file  │
-│                                                                       (repeat for multiple table │
-│                                                                       names, leave empty for all │
-│                                                                       tables in the file).       │
-│                                                                       [default: None]            │
-│    --iceberg-table                          TEXT                      Table name to assign to    │
-│                                                                       the model created from the │
-│                                                                       Iceberg schema.            │
-│                                                                       [default: None]            │
-│    --template                               TEXT                      The location (url or path) │
-│                                                                       of the ODCS template       │
-│                                                                       [default: None]            │
-│    --schema                                 TEXT                      The location (url or path) │
-│                                                                       of the ODCS JSON Schema    │
-│                                                                       [default: None]            │
-│    --owner                                  TEXT                      The owner or team          │
-│                                                                       responsible for managing   │
-│                                                                       the data contract.         │
-│                                                                       [default: None]            │
-│    --id                                     TEXT                      The identifier for the the │
-│                                                                       data contract.             │
-│                                                                       [default: None]            │
-│    --debug                    --no-debug                              Enable debug logging       │
-│                                                                       [default: no-debug]        │
-│    --help                                                             Show this message and      │
-│                                                                       exit.                      │
+│ --help          Show this message and exit.                                                      │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────╮
+│ sql         Import a data contract from a SQL DDL file.                                          │
+│ avro        Import a data contract from an Avro schema file.                                     │
+│ dbt         Import a data contract from a dbt manifest file.                                     │
+│ dbml        Import a data contract from a DBML file.                                             │
+│ glue        Import a data contract from AWS Glue.                                                │
+│ bigquery    Import a data contract from BigQuery.                                                │
+│ unity       Import a data contract from Databricks Unity Catalog.                                │
+│ jsonschema  Import a data contract from a JSON Schema file.                                      │
+│ json        Import a data contract from a JSON file.                                             │
+│ odcs        Import a data contract from an ODCS file.                                            │
+│ parquet     Import a data contract from a Parquet file.                                          │
+│ csv         Import a data contract from a CSV file.                                              │
+│ protobuf    Import a data contract from a Protobuf schema file.                                  │
+│ spark       Import a data contract from a Spark schema.                                          │
+│ iceberg     Import a data contract from an Iceberg schema.                                       │
+│ excel       Import a data contract from an Excel file.                                           │
 ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+ Example: datacontract import sql --source ddl.sql --dialect postgres --output datacontract.yaml
 ```
-Example:
+Run `datacontract import <format> --help` to see the format-specific options (e.g. `datacontract import sql --help`). If you are missing a format, please [create an issue on GitHub](https://github.com/datacontract/datacontract-cli/issues).
+#### Examples
 ```bash
 # Example import from SQL DDL
-datacontract import --format sql --source my_ddl.sql --dialect postgres
+datacontract import sql --source my_ddl.sql --dialect postgres
 # To save to file
-datacontract import --format sql --source my_ddl.sql --dialect postgres --output datacontract.yaml
+datacontract import sql --source my_ddl.sql --dialect postgres --output datacontract.yaml
 ```
-Available import options:
-| Type               | Description                                   | Status  |
-|--------------------|-----------------------------------------------|---------|
-| `avro`             | Import from AVRO schemas                      | ✅       |
-| `bigquery`         | Import from BigQuery Schemas                  | ✅       |
-| `csv`              | Import from CSV File                          | ✅       |
-| `dbml`             | Import from DBML models                       | ✅       |
-| `dbt`              | Import from dbt models                        | ✅       |
-| `excel`            | Import from ODCS Excel Template               | ✅       |
-| `glue`             | Import from AWS Glue DataCatalog              | ✅       |
-| `iceberg`          | Import from an Iceberg JSON Schema Definition | partial |
-| `jsonschema`       | Import from JSON Schemas                      | ✅       |
-| `parquet`          | Import from Parquet File Metadata             | ✅       |
-| `protobuf`         | Import from Protobuf schemas                  | ✅       |
-| `spark`            | Import from Spark StructTypes, Variant        | ✅       |
-| `sql`              | Import from SQL DDL                           | ✅       |
-| `unity`            | Import from Databricks Unity Catalog          | partial |
-| Missing something? | Please create an issue on GitHub              | TBD     |
-#### BigQuery
+<details markdown="1">
+<summary><strong>BigQuery</strong></summary>
 BigQuery data can either be imported off of JSON Files generated from the table descriptions or directly from the Bigquery API. In case you want to use JSON Files, specify the `source` parameter with a path to the JSON File.
-To import from the Bigquery API, you have to _omit_ `source` and instead need to provide `bigquery-project` and `bigquery-dataset`. Additionally you may specify `bigquery-table` to enumerate the tables that should be imported. If no tables are given, _all_ available tables of the dataset will be imported.
+To import from the Bigquery API, you have to _omit_ `source` and instead need to provide `--project` and `--dataset`. Additionally you may specify `--table` to enumerate the tables that should be imported. If no tables are given, _all_ available tables of the dataset will be imported.
 For providing authentication to the Client, please see [the google documentation](https://cloud.google.com/docs/authentication/provide-credentials-adc#how-to) or the one [about authorizing client libraries](https://cloud.google.com/bigquery/docs/authentication#client-libs).
@@ -1884,56 +1787,66 @@ Examples:
 ```bash
 # Example import from Bigquery JSON
-datacontract import --format bigquery --source my_bigquery_table.json
+datacontract import bigquery --source my_bigquery_table.json
 ```
 ```bash
 # Example import from Bigquery API with specifying the tables to import
-datacontract import --format bigquery --bigquery-project <project_id> --bigquery-dataset <dataset_id> --bigquery-table <tableid_1> --bigquery-table <tableid_2> --bigquery-table <tableid_3>
+datacontract import bigquery --project <project_id> --dataset <dataset_id> --table <tableid_1> --table <tableid_2> --table <tableid_3>
 ```
 ```bash
 # Example import from Bigquery API importing all tables in the dataset
-datacontract import --format bigquery --bigquery-project <project_id> --bigquery-dataset <dataset_id>
+datacontract import bigquery --project <project_id> --dataset <dataset_id>
 ```
-#### Unity Catalog
+</details>
+<details markdown="1">
+<summary><strong>Unity Catalog</strong></summary>
 ```bash
 # Example import from a Unity Catalog JSON file
-datacontract import --format unity --source my_unity_table.json
+datacontract import unity --source my_unity_table.json
 ```
 ```bash
 # Example import single table from Unity Catalog via HTTP endpoint using PAT
 export DATACONTRACT_DATABRICKS_SERVER_HOSTNAME="https://xyz.cloud.databricks.com"
 export DATACONTRACT_DATABRICKS_TOKEN=<token>
-datacontract import --format unity --unity-table-full-name <table_full_name>
+datacontract import unity --table <table_full_name>
 ```
  Please refer to [Databricks documentation](https://docs.databricks.com/aws/en/dev-tools/auth/unified-auth) on how to set up a profile
 ```bash
 # Example import single table from Unity Catalog via HTTP endpoint using Profile
 export DATACONTRACT_DATABRICKS_PROFILE="my-profile"
-datacontract import --format unity --unity-table-full-name <table_full_name>
+datacontract import unity --table <table_full_name>
 ```
-#### dbt
+</details>
+<details markdown="1">
+<summary><strong>dbt</strong></summary>
 Importing from dbt manifest file.
-You may give the `dbt-model` parameter to enumerate the tables that should be imported. If no tables are given, _all_ available tables of the database will be imported.
+You may give the `--model` parameter to enumerate the tables that should be imported. If no tables are given, _all_ available tables of the database will be imported.
 Examples:
 ```bash
 # Example import from dbt manifest with specifying the tables to import
-datacontract import --format dbt --source <manifest_path> --dbt-model <model_name_1> --dbt-model <model_name_2> --dbt-model <model_name_3>
+datacontract import dbt --source <manifest_path> --model <model_name_1> --model <model_name_2> --model <model_name_3>
 ```
 ```bash
 # Example import from dbt manifest importing all tables in the database
-datacontract import --format dbt --source <manifest_path>
+datacontract import dbt --source <manifest_path>
 ```
-#### Excel
+</details>
+<details markdown="1">
+<summary><strong>Excel</strong></summary>
 Importing from [ODCS Excel Template](https://github.com/datacontract/open-data-contract-standard-excel-template).
@@ -1941,33 +1854,39 @@ Examples:
 ```bash
 # Example import from ODCS Excel Template
-datacontract import --format excel --source odcs.xlsx
+datacontract import excel --source odcs.xlsx
 ```
-#### Glue
+</details>
+<details markdown="1">
+<summary><strong>Glue</strong></summary>
 Importing from Glue reads the necessary Data directly off of the AWS API.
-You may give the `glue-table` parameter to enumerate the tables that should be imported. If no tables are given, _all_ available tables of the database will be imported.
+You may give the `--table` parameter to enumerate the tables that should be imported. If no tables are given, _all_ available tables of the database will be imported.
 Examples:
 ```bash
 # Example import from AWS Glue with specifying the tables to import
-datacontract import --format glue --source <database_name> --glue-table <table_name_1> --glue-table <table_name_2> --glue-table <table_name_3>
+datacontract import glue --database <database_name> --table <table_name_1> --table <table_name_2> --table <table_name_3>
 ```
 ```bash
 # Example import from AWS Glue importing all tables in the database
-datacontract import --format glue --source <database_name>
+datacontract import glue --database <database_name>
 ```
-#### Spark
+</details>
+<details markdown="1">
+<summary><strong>Spark</strong></summary>
-Importing from Spark table or view these must be created or accessible in the Spark context. Specify tables list in `source` parameter.  If the `source` tables are registered as tables in Databricks, and they have a table-level descriptions they will also be added to the Data Contract Specification.
+Importing from Spark table or view these must be created or accessible in the Spark context. Specify tables list in the `--tables` option. If the tables are registered in Databricks and have a table-level description, it will also be added to the Data Contract Specification.
 ```bash
 # Example: Import Spark table(s) from Spark context
-datacontract import --format spark --source "users,orders"
+datacontract import spark --tables "users,orders"
 ```
 ```bash
@@ -1988,67 +1907,81 @@ DataContract.import_from_source("spark", "users", dataframe = df_user, descripti
 DataContract.import_from_source(format = "spark", source = "users", dataframe = df_user, description = "description")
 ```
-#### DBML
+</details>
+<details markdown="1">
+<summary><strong>DBML</strong></summary>
 Importing from DBML Documents.
 **NOTE:** Since DBML does _not_ have strict requirements on the types of columns, this import _may_ create non-valid datacontracts, as not all types of fields can be properly mapped. In this case you will have to adapt the generated document manually.
 We also assume, that the description for models and fields is stored in a Note within the DBML model.
-You may give the `dbml-table` or `dbml-schema` parameter to enumerate the tables or schemas that should be imported.
+You may give the `--table` or `--schema` parameter to enumerate the tables or schemas that should be imported.
 If no tables are given, _all_ available tables of the source will be imported. Likewise, if no schema is given, _all_ schemas are imported.
 Examples:
 ```bash
 # Example import from DBML file, importing everything
-datacontract import --format dbml --source <file_path>
+datacontract import dbml --source <file_path>
 ```
 ```bash
 # Example import from DBML file, filtering for tables from specific schemas
-datacontract import --format dbml --source <file_path> --dbml-schema <schema_1> --dbml-schema <schema_2>
+datacontract import dbml --source <file_path> --schema <schema_1> --schema <schema_2>
 ```
 ```bash
 # Example import from DBML file, filtering for tables with specific names
-datacontract import --format dbml --source <file_path> --dbml-table <table_name_1> --dbml-table <table_name_2>
+datacontract import dbml --source <file_path> --table <table_name_1> --table <table_name_2>
 ```
 ```bash
 # Example import from DBML file, filtering for tables with specific names from a specific schema
-datacontract import --format dbml --source <file_path> --dbml-table <table_name_1> --dbml-schema <schema_1>
+datacontract import dbml --source <file_path> --table <table_name_1> --schema <schema_1>
 ```
-#### Iceberg
+</details>
+<details markdown="1">
+<summary><strong>Iceberg</strong></summary>
 Importing from an [Iceberg Table Json Schema Definition](https://iceberg.apache.org/spec/#appendix-c-json-serialization). Specify location of json files using the `source` parameter.
 Examples:
 ```bash
-datacontract import --format iceberg --source ./tests/fixtures/iceberg/simple_schema.json --iceberg-table test-table
+datacontract import iceberg --source ./tests/fixtures/iceberg/simple_schema.json --table test-table
 ```
-#### CSV
+</details>
+<details markdown="1">
+<summary><strong>CSV</strong></summary>
 Importing from CSV File. Specify file in `source` parameter. It does autodetection for encoding and csv dialect
 Example:
 ```bash
-datacontract import --format csv --source "test.csv"
+datacontract import csv --source "test.csv"
 ```
-#### protobuf
+</details>
+<details markdown="1">
+<summary><strong>protobuf</strong></summary>
 Importing from protobuf File. Specify file in `source` parameter.
 Example:
 ```bash
-datacontract import --format protobuf --source "test.proto"
+datacontract import protobuf --source "test.proto"
 ```
+</details>
 ### catalog
 ```
@@ -2057,17 +1990,19 @@ datacontract import --format protobuf --source "test.proto"
  Create a html catalog of data contracts.
 ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮
-│ --files                   TEXT  Glob pattern for the data contract files to include in the       │
-│                                 catalog. Applies recursively to any subfolders.                  │
-│                                 [default: *.yaml]                                                │
-│ --output                  TEXT  Output directory for the catalog html files. [default: catalog/] │
-│ --schema                  TEXT  The location (url or path) of the ODCS JSON Schema               │
-│                                 [default: None]                                                  │
-│ --debug     --no-debug          Enable debug logging [default: no-debug]                         │
-│ --help                          Show this message and exit.                                      │
+│ --files                        TEXT  Glob pattern for the data contract files to include in the  │
+│                                      catalog. Applies recursively to any subfolders.             │
+│                                      [default: *.yaml]                                           │
+│ --output                       TEXT  Output directory for the catalog html files.                │
+│                                      [default: catalog/]                                         │
+│ --json-schema                  TEXT  The location (url or path) of the ODCS JSON Schema          │
+│ --debug          --no-debug          Enable debug logging                                        │
+│ --help                               Show this message and exit.                                 │
 ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+ Example: datacontract catalog --files "**/*.yaml" --output catalog/
 ```
@@ -2088,21 +2023,22 @@ datacontract catalog --files "*.odcs.yaml"
  Publish the data contract to the Entropy Data.
 ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮
 │   location      [LOCATION]  The location (url or path) of the data contract yaml.                │
 │                             [default: datacontract.yaml]                                         │
 ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
 ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮
-│ --schema                                       TEXT  The location (url or path) of the ODCS JSON │
+│ --json-schema                                  TEXT  The location (url or path) of the ODCS JSON │
 │                                                      Schema                                      │
-│                                                      [default: None]                             │
 │ --ssl-verification    --no-ssl-verification          SSL verification when publishing the data   │
 │                                                      contract.                                   │
 │                                                      [default: ssl-verification]                 │
-│ --debug               --no-debug                     Enable debug logging [default: no-debug]    │
+│ --debug               --no-debug                     Enable debug logging                        │
 │ --help                                               Show this message and exit.                 │
 ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+ Example: datacontract publish datacontract.yaml
 ```
@@ -2113,14 +2049,19 @@ datacontract catalog --files "*.odcs.yaml"
  Start the datacontract CLI as server application with REST API.
- The OpenAPI documentation as Swagger UI is available on http://localhost:4242. You can execute the
- commands directly from the Swagger UI.
+ The OpenAPI documentation as Swagger UI is available on http://localhost:4242.
+ You can execute the commands directly from the Swagger UI.
  To protect the API, you can set the environment variable DATACONTRACT_CLI_API_KEY to a secret API
- key. To authenticate, requests must include the header 'x-api-key' with the correct API key. This
- is highly recommended, as data contract tests may be subject to SQL injections or leak sensitive
- information.
+ key.
+ To authenticate, requests must include the header 'x-api-key' with the correct API key.
+ 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
+ variables as documented in
+ https://cli.datacontract.com/#test
  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`.
@@ -2129,9 +2070,12 @@ datacontract catalog --files "*.odcs.yaml"
 │ --host                   TEXT     Bind socket to this host. Hint: For running in docker, set it  │
 │                                   to 0.0.0.0                                                     │
 │                                   [default: 127.0.0.1]                                           │
-│ --debug    --no-debug             Enable debug logging [default: no-debug]                       │
+│ --debug    --no-debug             Enable debug logging                                           │
 │ --help                            Show this message and exit.                                    │
 ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+ Example: datacontract api --port 4242 --host 0.0.0.0
 ```
@@ -2163,7 +2107,7 @@ Create a data contract based on the actual data. This is the fastest way to get
 1. Use an existing physical schema (e.g., SQL DDL) as a starting point to define your logical data model in the contract. Double check right after the import whether the actual data meets the imported logical data model. Just to be sure.
     ```bash
-    $ datacontract import --format sql --source ddl.sql
+    $ datacontract import sql --source ddl.sql
     $ datacontract test
     ```
@@ -2204,10 +2148,10 @@ Create a data contract based on the requirements from use cases.
    into the consuming data products.
     ```bash
     # data provider
-    $ datacontract export --format dbt
+    $ datacontract export dbt-models
     # data consumer
-    $ datacontract export --format dbt-sources
-    $ datacontract export --format dbt-staging-sql
+    $ datacontract export dbt-sources
+    $ datacontract export dbt-staging-sql
     ```
 4. Test that your data product implementation adheres to the contract.

datacontract-cli 0.11.9__tar.gz → 0.12.0__tar.gz

datacontract-cli 0.11.9tar.gz → 0.12.0tar.gz