dataproduct-cli 0.0.1__tar.gz → 0.2.0__tar.gz

{dataproduct_cli-0.0.1 → dataproduct_cli-0.2.0}/CHANGELOG.md

@@ -5,12 +5,18 @@ what changed (user-facing).
 
 ## [Unreleased]
 
-## [0.0.1]
+## [0.2.0]
 
-- Test release to validate the PyPI publishing pipeline
+- Support ODPS v1.1.0: `lint` validates against the bundled v1.1.0 JSON Schema (`type`, `context`, `synonyms`, `deprecated`, `customProperties[].vendor`, element `id`s, optional port `version`/`contractId`)
+- `lint` validates against the bundled JSON Schema for the `apiVersion` the document declares (`v1.1.0` → v1.1.0 schema; `v1.0.0`/`v0.9.0` → v1.0.0 schema; unknown → newest), and check names state which schema ran
+- `init` template now uses `apiVersion: v1.1.0`
 
 ## [0.1.0]
 
 - `init` command: create a valid `dataproduct.odps.yaml` from a bundled ODPS v1.0.0 template
 - `lint` command: validate a data product against the ODPS v1.0.0 JSON Schema (json/junit output)
 - `publish` command: publish a data product to Entropy Data (`PUT /api/dataproducts/{id}`)
+
+## [0.0.1]
+
+- Test release to validate the PyPI publishing pipeline

{dataproduct_cli-0.0.1/dataproduct_cli.egg-info → dataproduct_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataproduct-cli
-Version: 0.0.1
+Version: 0.2.0
 Summary: The dataproduct CLI is an open source command-line tool for working with data products. It uses data product YAML files following the Open Data Product Standard (ODPS) to lint the definition against the standard and publish it to Entropy Data. 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: Michael Kutz <michael.kutz@entropy-data.com>
 License-Expression: MIT
@@ -44,7 +44,7 @@ Dynamic: license-file
 
 The `dataproduct` CLI is an open-source command-line tool for working with
 **data products** defined with the
-[Open Data Product Standard (ODPS)](https://bitol-io.github.io/open-data-product-standard/v1.0.0/).
+[Open Data Product Standard (ODPS)](https://bitol-io.github.io/open-data-product-standard/v1.1.0/).
 
 It is the data-product sibling of
 [`datacontract-cli`](https://github.com/datacontract/datacontract-cli) (which
@@ -83,8 +83,10 @@ dataproduct lint --output-format junit --output TEST-dataproduct.xml
 dataproduct lint --json-schema ./odps.schema.json  # validate against a custom schema
 ```
 
-Validation is schema-only in 0.1: the data product is checked against the
-bundled ODPS v1.0.0 JSON Schema. Exit code is `0` when valid, `1` otherwise.
+Validation is schema-only: the data product is checked against the bundled
+ODPS JSON Schema matching its `apiVersion` (`v1.1.0`, `v1.0.0`, or `v0.9.0`;
+unknown versions are validated against the latest). Exit code is `0` when
+valid, `1` otherwise.
 
 ### `publish` — publish to Entropy Data
 

{dataproduct_cli-0.0.1 → dataproduct_cli-0.2.0}/README.md

@@ -2,7 +2,7 @@
 
 The `dataproduct` CLI is an open-source command-line tool for working with
 **data products** defined with the
-[Open Data Product Standard (ODPS)](https://bitol-io.github.io/open-data-product-standard/v1.0.0/).
+[Open Data Product Standard (ODPS)](https://bitol-io.github.io/open-data-product-standard/v1.1.0/).
 
 It is the data-product sibling of
 [`datacontract-cli`](https://github.com/datacontract/datacontract-cli) (which
@@ -41,8 +41,10 @@ dataproduct lint --output-format junit --output TEST-dataproduct.xml
 dataproduct lint --json-schema ./odps.schema.json  # validate against a custom schema
 ```
 
-Validation is schema-only in 0.1: the data product is checked against the
-bundled ODPS v1.0.0 JSON Schema. Exit code is `0` when valid, `1` otherwise.
+Validation is schema-only: the data product is checked against the bundled
+ODPS JSON Schema matching its `apiVersion` (`v1.1.0`, `v1.0.0`, or `v0.9.0`;
+unknown versions are validated against the latest). Exit code is `0` when
+valid, `1` otherwise.
 
 ### `publish` — publish to Entropy Data
 

{dataproduct_cli-0.0.1 → dataproduct_cli-0.2.0}/dataproduct/data_product.py

@@ -11,7 +11,7 @@ from typing import Optional, Union
 from dataproduct.config import Config
 from dataproduct.integration.entropy_data import publish_data_product_to_entropy_data
 from dataproduct.lint.files import read_resource
-from dataproduct.lint.schema import fetch_schema
+from dataproduct.lint.schema import fetch_schema, schema_version_for
 from dataproduct.lint.validate import parse_yaml, validate_against_schema
 from dataproduct.model.exceptions import DataProductException
 from dataproduct.model.run import Check, ResultEnum, Run
@@ -46,15 +46,16 @@ class DataProduct:
         return parse_yaml(content)
 
     def lint(self) -> Run:
-        """Validate the data product against the ODPS JSON Schema (schema-only)."""
+        """Validate the data product against the ODPS JSON Schema matching its ``apiVersion`` (schema-only)."""
         run = Run.create_run()
         run.log_info("Linting data product")
         try:
             data = self._load_dict()
             run.dataProductId = data.get("id")
             run.dataProductVersion = data.get("version")
-            schema = fetch_schema(self._schema_location)
-            checks = validate_against_schema(data, schema, self._all_errors)
+            schema_version = None if self._schema_location else schema_version_for(data.get("apiVersion"))
+            schema = fetch_schema(self._schema_location, schema_version)
+            checks = validate_against_schema(data, schema, self._all_errors, schema_version)
             if checks:
                 run.checks.extend(checks)
                 for check in checks:
@@ -64,7 +65,9 @@ class DataProduct:
                     Check(
                         type="lint",
                         result=ResultEnum.passed,
-                        name="Data product is syntactically valid",
+                        name="Data product is syntactically valid"
+                        if schema_version is None
+                        else f"Data product is valid against ODPS v{schema_version}",
                     )
                 )
         except DataProductException as e:

{dataproduct_cli-0.0.1 → dataproduct_cli-0.2.0}/dataproduct/init/init_template.py

@@ -3,7 +3,7 @@ import logging
 
 import requests
 
-DEFAULT_DATA_PRODUCT_INIT_TEMPLATE = "odps-1.0.0.init.yaml"
+DEFAULT_DATA_PRODUCT_INIT_TEMPLATE = "odps-1.1.0.init.yaml"
 
 
 def get_init_template(location: str = None) -> str:

dataproduct_cli-0.2.0/dataproduct/lint/schema.py

@@ -0,0 +1,64 @@
+import importlib.resources as resources
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+import requests
+
+from dataproduct.model.exceptions import DataProductException
+from dataproduct.model.run import ResultEnum
+
+# ODPS v1.1.0 relaxed several required fields (e.g. `status`, port `version`/`contractId`)
+# and added new ones, so older documents must be validated against their own schema.
+# v0.9.0 has no dedicated bundled schema; the v1.0.0 schema accepts it.
+ODPS_SCHEMA_VERSIONS = {
+    "v1.1.0": "1.1.0",
+    "v1.0.0": "1.0.0",
+    "v0.9.0": "1.0.0",
+}
+DEFAULT_ODPS_SCHEMA_VERSION = "1.1.0"
+
+
+def schema_version_for(api_version: Any = None) -> str:
+    """Return the bundled ODPS schema version for a document's ``apiVersion``.
+
+    Unknown or missing versions fall back to the newest bundled schema, which
+    then reports the invalid ``apiVersion`` as a schema violation.
+    """
+    if isinstance(api_version, str):
+        return ODPS_SCHEMA_VERSIONS.get(api_version, DEFAULT_ODPS_SCHEMA_VERSION)
+    return DEFAULT_ODPS_SCHEMA_VERSION
+
+
+def fetch_schema(location: Union[str, Path] = None, schema_version: Optional[str] = None) -> Dict[str, Any]:
+    """Fetch the ODPS JSON Schema to validate against.
+
+    ``None`` uses the bundled schema for ``schema_version`` (newest when
+    omitted); otherwise ``location`` is a URL or local path.
+    """
+    if location is None:
+        schema_name = f"odps-{schema_version or DEFAULT_ODPS_SCHEMA_VERSION}.schema.json"
+        logging.info("Use default bundled schema " + schema_name)
+        schemas = resources.files("dataproduct")
+        schema_file = schemas.joinpath("schemas", schema_name)
+        with schema_file.open("r") as file:
+            return json.load(file)
+
+    location_str = str(location)
+    if location_str.startswith("http://") or location_str.startswith("https://"):
+        logging.debug(f"Downloading schema from {location_str}")
+        response = requests.get(location_str)
+        return response.json()
+
+    if not os.path.exists(location_str):
+        raise DataProductException(
+            type="lint",
+            name=f"Reading schema from {location_str}",
+            reason=f"The file '{location_str}' does not exist.",
+            result=ResultEnum.error,
+        )
+    logging.debug(f"Loading JSON schema locally at {location_str}")
+    with open(location_str, "r") as file:
+        return json.load(file)

{dataproduct_cli-0.0.1 → dataproduct_cli-0.2.0}/dataproduct/lint/validate.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 import yaml
 from jsonschema.validators import validator_for
@@ -32,11 +32,15 @@ def parse_yaml(content: str) -> Dict[str, Any]:
     return data
 
 
-def validate_against_schema(data: Dict[str, Any], schema: Dict[str, Any], all_errors: bool = False) -> List[Check]:
+def validate_against_schema(
+    data: Dict[str, Any], schema: Dict[str, Any], all_errors: bool = False, schema_version: Optional[str] = None
+) -> List[Check]:
     """Validate ``data`` against the ODPS JSON Schema.
 
     Returns a list of ``error`` checks — empty when the document is valid. With
-    ``all_errors=False`` (default) only the first violation is reported.
+    ``all_errors=False`` (default) only the first violation is reported. Check
+    names state the bundled ``schema_version`` that ran; ``None`` means a custom
+    schema was supplied and no version is named.
     """
     validator_cls = validator_for(schema)
     validator_cls.check_schema(schema)
@@ -46,16 +50,21 @@ def validate_against_schema(data: Dict[str, Any], schema: Dict[str, Any], all_er
     if not all_errors:
         errors = errors[:1]
 
+    name = (
+        "Check that data product YAML is valid"
+        if schema_version is None
+        else f"Check that data product is valid against ODPS v{schema_version}"
+    )
     checks: List[Check] = []
     for error in errors:
-        path = "/".join(str(p) for p in error.absolute_path) or "(root)"
+        path = "/".join(str(p) for p in error.absolute_path)
         checks.append(
             Check(
                 type="lint",
                 result=ResultEnum.error,
-                name=f"Schema validation failed at '{path}'",
-                reason=error.message,
-                field=path,
+                name=name,
+                reason=f"{path}: {error.message}" if path else error.message,
+                field=path or "(root)",
             )
         )
     return checks

dataproduct_cli-0.0.1/dataproduct/schemas/odps-1.0.0.init.yaml → dataproduct_cli-0.2.0/dataproduct/schemas/odps-1.1.0.init.yaml

@@ -1,9 +1,10 @@
-apiVersion: v1.0.0
+apiVersion: v1.1.0
 kind: DataProduct
 id: my-data-product-id
 name: My Data Product
 version: v1.0.0
 status: draft
+# type: consumerAligned  # sourceAligned | aggregate | consumerAligned
 
 description:
   purpose: Purpose of the data product.

dataproduct_cli-0.2.0/dataproduct/schemas/odps-1.1.0.schema.json

@@ -0,0 +1,717 @@
+{
+  "$schema": "https://json-schema.org/draft/2019-09/schema",
+  "title": "Open Data Product Standard (ODPS)",
+  "description": "An open data product standard descriptor to enable defining data products.",
+  "type": "object",
+  "required": ["apiVersion", "kind", "id"],
+  "additionalProperties": false,
+  "properties": {
+    "apiVersion": {
+      "type": "string",
+      "default": "v1.1.0",
+      "description": "Version of the standard used to build data product. Default value is v1.1.0.",
+      "enum": ["v1.1.0", "v1.0.0", "v0.9.0"]
+    },
+    "kind": {
+      "type": "string",
+      "default": "DataProduct",
+      "description": "The kind of file this is. Valid value is `DataProduct`.",
+      "enum": ["DataProduct"]
+    },
+    "id": {
+      "type": "string",
+      "description": "A unique identifier used to reduce the risk of dataset name collisions, such as a UUID."
+    },
+    "name": {
+      "type": "string",
+      "description": "Name of the data product."
+    },
+    "deprecated": {
+      "type": "boolean",
+      "description": "Indicates this data product is deprecated and should not be used in new implementations. Defaults to false.",
+      "default": false
+    },
+    "synonyms": {
+      "$ref": "#/$defs/Synonyms"
+    },
+    "version": {
+      "type": "string",
+      "description": "Current version of the data product. Not required, but highly recommended."
+    },
+    "status": {
+      "type": "string",
+      "description": "Current status of the data product.",
+      "examples": ["proposed", "draft", "active", "deprecated", "retired"]
+    },
+    "domain": {
+      "type": "string",
+      "description": "Business domain"
+    },
+    "type": {
+      "type": "string",
+      "description": "Architectural type of the data product. Common values: `sourceAligned`, `aggregate`, `consumerAligned`. Organizations may define custom types."
+    },
+    "context": {
+      "$ref": "#/$defs/Context"
+    },
+    "tenant": {
+      "type": "string",
+      "description": "Organization identifier"
+    },
+    "authoritativeDefinitions": {
+      "type": "array",
+      "description": "List of links to sources that provide more details on the data contract.",
+      "items": {
+        "$ref": "#/$defs/AuthoritativeDefinition"
+      }
+    },
+    "description": {
+      "$ref": "#/$defs/Description"
+    },
+    "customProperties": {
+      "type": "array",
+      "description": "A list of key/value pairs for custom properties.",
+      "items": {
+        "$ref": "#/$defs/CustomProperty"
+      }
+    },
+    "tags": {
+      "$ref": "#/$defs/Tags"
+    },
+    "inputPorts": {
+      "type": "array",
+      "description": "List of objects describing an input port. You need at least one as a data product needs to get data somewhere.",
+      "items": {
+        "$ref": "#/$defs/InputPort"
+      }
+    },
+    "outputPorts": {
+      "type": "array",
+      "description": "List of objects describing an output port. You need at least one, as a data product without output is useless.",
+      "items": {
+        "$ref": "#/$defs/OutputPort"
+      }
+    },
+    "managementPorts": {
+      "type": "array",
+      "description": "Management ports define access points for managing the data product.",
+      "items": {
+        "$ref": "#/$defs/ManagementPort"
+      }
+    },
+    "support": {
+      "type": "array",
+      "description": "Support and communication channels.",
+      "items": {
+        "$ref": "#/$defs/Support"
+      }
+    },
+    "team": {
+      "$ref": "#/$defs/Team"
+    },
+    "productCreatedTs": {
+      "type": "string",
+      "format": "date-time",
+      "description": "Timestamp in UTC of when the data product was created, using ISO 8601."
+    }
+  },
+  "$defs": {
+    "Tags": {
+      "type": "array",
+      "description": "A list of tags that may be assigned to the elements (object or property); the tags keyword may appear at any level. Tags may be used to better categorize an element. For example, `finance`, `sensitive`, `employee_record`.",
+      "examples": ["finance", "sensitive", "employee_record"],
+      "items": {
+        "type": "string"
+      }
+    },
+    "Description": {
+      "type": "object",
+      "description": "Object containing the descriptions.",
+      "additionalProperties": false,
+      "properties": {
+        "purpose": {
+          "type": "string",
+          "description": "Intended purpose for the provided data."
+        },
+        "limitations": {
+          "type": "string",
+          "description": "Technical, compliance, and legal limitations for data use."
+        },
+        "usage": {
+          "type": "string",
+          "description": "Recommended usage of the data."
+        },
+        "authoritativeDefinitions": {
+          "type": "array",
+          "description": "List of links to sources that provide more details on the data contract.",
+          "items": {
+            "$ref": "#/$defs/AuthoritativeDefinition"
+          }
+        },
+        "customProperties": {
+          "type": "array",
+          "description": "A list of key/value pairs for custom properties.",
+          "items": {
+            "$ref": "#/$defs/CustomProperty"
+          }
+        }
+      }
+    },
+    "CustomProperty": {
+      "type": "object",
+      "description": "A key/value pair for custom properties.",
+      "additionalProperties": false,
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "A unique identifier for the element used to create stable, refactor-safe references. Recommended for elements that will be referenced."
+        },
+        "property": {
+          "type": "string",
+          "description": "The name of the key. Names should be in camel case, the same as if they were permanent properties in the contract."
+        },
+        "value": {
+          "description": "The value of the key."
+        },
+        "description": {
+          "type": "string",
+          "description": "Optional description."
+        },
+        "vendor": {
+          "type": "string",
+          "description": "Identifies the vendor, provider, or external system associated with this custom property. SHOULD be a stable, lowercase identifier matching ^[a-z0-9][a-z0-9-]*$ (e.g. confluent, zeenea, atlan, soda). Tools MUST preserve unknown vendor values.",
+          "examples": ["confluent", "zeenea", "atlan", "soda"]
+        }
+      },
+      "required": ["property", "value"]
+    },
+    "Synonyms": {
+      "type": "array",
+      "description": "A list of alternative names for the object. See RFC 0041.",
+      "items": {
+        "$ref": "#/$defs/Synonym"
+      }
+    },
+    "Synonym": {
+      "type": "object",
+      "description": "An alternative name for a named object, helping catalogs, AI/LLM tools, and natural language interfaces resolve business vocabulary to the underlying object. See RFC 0041.",
+      "additionalProperties": false,
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "A unique identifier for the synonym, useful when referencing or deduplicating synonyms across tools. Recommended for elements that will be referenced."
+        },
+        "synonym": {
+          "type": "string",
+          "description": "The synonymous term."
+        },
+        "description": {
+          "type": "string",
+          "description": "Short human-readable note about when or why this synonym is used."
+        },
+        "locale": {
+          "type": "string",
+          "description": "BCP 47 language tag (e.g., `en-US`, `fr-FR`) when the synonym is language-specific."
+        },
+        "source": {
+          "type": "string",
+          "description": "Origin of the synonym (e.g., `glossary`, `finance-team`, `legacy-system`)."
+        },
+        "status": {
+          "type": "string",
+          "description": "Lifecycle status of the synonym (e.g., `active`, `deprecated`)."
+        },
+        "customProperties": {
+          "type": "array",
+          "description": "Custom properties block.",
+          "items": {
+            "$ref": "#/$defs/CustomProperty"
+          }
+        }
+      },
+      "required": ["synonym"]
+    },
+    "AuthoritativeDefinition": {
+      "type": "object",
+      "description": "A type/link pair for authoritative definitions.",
+      "additionalProperties": false,
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "A unique identifier for the element used to create stable, refactor-safe references. Recommended for elements that will be referenced."
+        },
+        "type": {
+          "type": "string",
+          "description": "Type of definition for authority.",
+          "examples": ["businessDefinition", "canonicalUrl", "glossary", "implementation", "ontology", "taxonomy", "transformationImplementation", "tutorial", "videoTutorial"]
+        },
+        "url": {
+          "type": "string",
+          "format": "uri",
+          "description": "URL to the authority."
+        },
+        "description": {
+          "type": "string",
+          "description": "Optional description."
+        }
+      },
+      "required": ["type", "url"]
+    },
+    "InputPort": {
+      "type": "object",
+      "description": "An input port describing expectations.",
+      "additionalProperties": false,
+      "properties": {
+        "deprecated": {
+          "type": "boolean",
+          "description": "Indicates this input port is deprecated and should not be used in new implementations. Defaults to false.",
+          "default": false
+        },
+        "id": {
+          "type": "string",
+          "description": "A unique identifier for the element used to create stable, refactor-safe references. Recommended for elements that will be referenced."
+        },
+        "name": {
+          "type": "string",
+          "description": "Name of the input port."
+        },
+        "version": {
+          "type": "string",
+          "description": "Version of the input port."
+        },
+        "contractId": {
+          "type": "string",
+          "description": "Contract ID for the input port."
+        },
+        "tags": {
+          "$ref": "#/$defs/Tags"
+        },
+        "customProperties": {
+          "type": "array",
+          "description": "Custom properties block.",
+          "items": {
+            "$ref": "#/$defs/CustomProperty"
+          }
+        },
+        "authoritativeDefinitions": {
+          "type": "array",
+          "description": "Authoritative definitions block.",
+          "items": {
+            "$ref": "#/$defs/AuthoritativeDefinition"
+          }
+        }
+      },
+      "required": ["name"]
+    },
+    "OutputPort": {
+      "type": "object",
+      "description": "An output port describing promises.",
+      "additionalProperties": false,
+      "properties": {
+        "deprecated": {
+          "type": "boolean",
+          "description": "Indicates this output port is deprecated and should not be used in new implementations. Defaults to false.",
+          "default": false
+        },
+        "id": {
+          "type": "string",
+          "description": "A unique identifier for the element used to create stable, refactor-safe references. Recommended for elements that will be referenced."
+        },
+        "name": {
+          "type": "string",
+          "description": "Name of the output port."
+        },
+        "description": {
+          "type": "string",
+          "description": "Human readable short description of the output port."
+        },
+        "type": {
+          "type": "string",
+          "description": "There can be different types of output ports, each automated and handled differently. Here you can indicate the type."
+        },
+        "version": {
+          "type": "string",
+          "description": "For each version, a different instance of the output port is listed. The combination of the name and version is the key."
+        },
+        "contractId": {
+          "type": "string",
+          "description": "Contract ID for the output port."
+        },
+        "sbom": {
+          "type": "array",
+          "description": "The SBOM can/should be at the version level.",
+          "items": {
+            "$ref": "#/$defs/SBOM"
+          }
+        },
+        "inputContracts": {
+          "type": "array",
+          "description": "Dependencies or input contracts.",
+          "items": {
+            "$ref": "#/$defs/InputContract"
+          }
+        },
+        "synonyms": {
+          "$ref": "#/$defs/Synonyms"
+        },
+        "tags": {
+          "$ref": "#/$defs/Tags"
+        },
+        "customProperties": {
+          "type": "array",
+          "description": "Custom properties block.",
+          "items": {
+            "$ref": "#/$defs/CustomProperty"
+          }
+        },
+        "authoritativeDefinitions": {
+          "type": "array",
+          "description": "Authoritative definitions block.",
+          "items": {
+            "$ref": "#/$defs/AuthoritativeDefinition"
+          }
+        },
+        "context": {
+          "$ref": "#/$defs/Context"
+        }
+      },
+      "required": ["name"]
+    },
+    "SBOM": {
+      "type": "object",
+      "description": "Software Bill of Materials.",
+      "additionalProperties": false,
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "A unique identifier for the element used to create stable, refactor-safe references. Recommended for elements that will be referenced."
+        },
+        "type": {
+          "type": "string",
+          "default": "external",
+          "description": "Type of SBOM."
+        },
+        "url": {
+          "type": "string",
+          "format": "uri",
+          "description": "URL to the SBOM."
+        },
+        "tags": { "$ref": "#/$defs/Tags" },
+        "customProperties": {
+          "type": "array",
+          "description": "Custom properties block.",
+          "items": { "$ref": "#/$defs/CustomProperty" }
+        },
+        "authoritativeDefinitions": {
+          "type": "array",
+          "description": "Authoritative definitions block.",
+          "items": { "$ref": "#/$defs/AuthoritativeDefinition" }
+        }
+      }
+    },
+    "InputContract": {
+      "type": "object",
+      "description": "Input contract dependency.",
+      "additionalProperties": false,
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "Contract ID or contractId."
+        },
+        "version": {
+          "type": "string",
+          "description": "Version of the input contract."
+        }
+      },
+      "required": ["id", "version"]
+    },
+    "ManagementPort": {
+      "type": "object",
+      "description": "Management port for managing the data product.",
+      "additionalProperties": false,
+      "properties": {
+        "deprecated": {
+          "type": "boolean",
+          "description": "Indicates this management port is deprecated and should not be used in new implementations. Defaults to false.",
+          "default": false
+        },
+        "id": {
+          "type": "string",
+          "description": "A unique identifier for the element used to create stable, refactor-safe references. Recommended for elements that will be referenced."
+        },
+        "name": {
+          "type": "string",
+          "description": "Endpoint identifier or unique name."
+        },
+        "content": {
+          "type": "string",
+          "description": "Content type.",
+          "examples": ["discoverability", "observability", "control", "dictionary"]
+        },
+        "type": {
+          "type": "string",
+          "default": "rest",
+          "description": "Type: can be `rest` or `topic`. Default is `rest`.",
+          "examples": ["rest", "topic"]
+        },
+        "url": {
+          "type": "string",
+          "format": "uri",
+          "description": "URL to access the endpoint."
+        },
+        "channel": {
+          "type": "string",
+          "description": "Channel to communicate with the data product."
+        },
+        "description": {
+          "type": "string",
+          "description": "Purpose and usage."
+        },
+        "tags": {
+          "$ref": "#/$defs/Tags"
+        },
+        "customProperties": {
+          "type": "array",
+          "description": "Custom properties block.",
+          "items": {
+            "$ref": "#/$defs/CustomProperty"
+          }
+        },
+        "authoritativeDefinitions": {
+          "type": "array",
+          "description": "Authoritative definitions block.",
+          "items": {
+            "$ref": "#/$defs/AuthoritativeDefinition"
+          }
+        }
+      },
+      "required": ["name", "content"]
+    },
+    "Support": {
+      "type": "object",
+      "description": "Support channel.",
+      "additionalProperties": false,
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "A unique identifier for the element used to create stable, refactor-safe references. Recommended for elements that will be referenced."
+        },
+        "channel": {
+          "type": "string",
+          "description": "Channel name or identifier."
+        },
+        "url": {
+          "type": "string",
+          "format": "uri",
+          "description": "Access URL using normal URL scheme (https, mailto, etc.)."
+        },
+        "description": {
+          "type": "string",
+          "description": "Description of the channel, free text."
+        },
+        "tool": {
+          "type": "string",
+          "description": "Name of the tool.",
+          "examples": ["email", "slack", "teams", "discord", "ticket", "other"]
+        },
+        "scope": {
+          "type": "string",
+          "description": "Scope can be: `interactive`, `announcements`, `issues`.",
+          "examples": ["interactive", "announcements", "issues"]
+        },
+        "invitationUrl": {
+          "type": "string",
+          "format": "uri",
+          "description": "Some tools uses invitation URL for requesting or subscribing. Follows the URL scheme."
+        },
+        "tags": {
+          "$ref": "#/$defs/Tags"
+        },
+        "customProperties": {
+          "type": "array",
+          "description": "Custom properties block.",
+          "items": {
+            "$ref": "#/$defs/CustomProperty"
+          }
+        },
+        "authoritativeDefinitions": {
+          "type": "array",
+          "description": "Authoritative definitions block.",
+          "items": {
+            "$ref": "#/$defs/AuthoritativeDefinition"
+          }
+        }
+      },
+      "required": ["channel", "url"]
+    },
+    "TeamMember": {
+      "type": "object",
+      "description": "Team member information.",
+      "additionalProperties": false,
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "A unique identifier for the element used to create stable, refactor-safe references. Recommended for elements that will be referenced."
+        },
+        "username": {
+          "type": "string",
+          "description": "The user's username or email."
+        },
+        "name": {
+          "type": "string",
+          "description": "The user's name."
+        },
+        "description": {
+          "type": "string",
+          "description": "The user's description."
+        },
+        "role": {
+          "type": "string",
+          "description": "The user's job role; Examples might be owner, data steward. There is no limit on the role."
+        },
+        "dateIn": {
+          "type": "string",
+          "format": "date",
+          "description": "The date when the user joined the team."
+        },
+        "dateOut": {
+          "type": "string",
+          "format": "date",
+          "description": "The date when the user ceased to be part of the team."
+        },
+        "replacedByUsername": {
+          "type": "string",
+          "description": "The username of the user who replaced the previous user."
+        },
+        "tags": {
+          "$ref": "#/$defs/Tags"
+        },
+        "customProperties": {
+          "type": "array",
+          "description": "Custom properties block.",
+          "items": {
+            "$ref": "#/$defs/CustomProperty"
+          }
+        },
+        "authoritativeDefinitions": {
+          "type": "array",
+          "description": "Authoritative definitions block.",
+          "items": {
+            "$ref": "#/$defs/AuthoritativeDefinition"
+          }
+        }
+      },
+      "required": ["username"]
+    },
+    "Context": {
+      "type": "object",
+      "description": "AI and semantic context block (RFC-0038). Provides structured guidance for AI agents, LLMs, BI tools, and semantic layer platforms. Optional and additive. Applicable at the data product (top level) and output port levels. Input ports refer to the linked ODCS contract's context instead.",
+      "additionalProperties": false,
+      "properties": {
+        "instructions": {
+          "type": "string",
+          "description": "Natural language guidance for AI agents and tools on how to use this entity. Equivalent to a system prompt scoped to this level."
+        },
+        "verifiedStatements": {
+          "type": "array",
+          "description": "Canonical business questions, each with an optional curated answer. Entries with `answer` should be returned verbatim by AI agents when a query is semantically close; entries without `answer` serve as sample questions for text-to-SQL priming and disambiguation.",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "id": {
+                "type": "string",
+                "description": "Stable identifier for the entry, useful when referencing or deduplicating verified statements across tools."
+              },
+              "question": {
+                "type": "string",
+                "description": "The canonical question."
+              },
+              "answer": {
+                "type": "string",
+                "description": "The expected response or result description. Optional — omit to signal an unanswered sample question."
+              },
+              "authoritativeDefinitions": {
+                "type": "array",
+                "items": { "$ref": "#/$defs/AuthoritativeDefinition" }
+              },
+              "tags": { "$ref": "#/$defs/Tags" },
+              "customProperties": {
+                "type": "array",
+                "items": { "$ref": "#/$defs/CustomProperty" }
+              }
+            },
+            "required": ["question"]
+          }
+        },
+        "constraints": {
+          "type": "array",
+          "description": "Negative guidance: what AI agents must NOT do with this entity.",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "id": {
+                "type": "string",
+                "description": "Stable identifier for the constraint."
+              },
+              "constraint": {
+                "type": "string",
+                "description": "The constraint text (negative guidance for AI agents)."
+              },
+              "authoritativeDefinitions": {
+                "type": "array",
+                "items": { "$ref": "#/$defs/AuthoritativeDefinition" }
+              },
+              "tags": { "$ref": "#/$defs/Tags" },
+              "customProperties": {
+                "type": "array",
+                "items": { "$ref": "#/$defs/CustomProperty" }
+              }
+            },
+            "required": ["constraint"]
+          }
+        }
+      }
+    },
+    "Team": {
+      "type": "object",
+      "description": "Team information.",
+      "additionalProperties": false,
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "Team name."
+        },
+        "description": {
+          "type": "string",
+          "description": "Team description."
+        },
+        "members": {
+          "type": "array",
+          "description": "List of members.",
+          "items": {
+            "$ref": "#/$defs/TeamMember"
+          }
+        },
+        "tags": {
+          "$ref": "#/$defs/Tags"
+        },
+        "customProperties": {
+          "type": "array",
+          "description": "Custom properties block.",
+          "items": {
+            "$ref": "#/$defs/CustomProperty"
+          }
+        },
+        "authoritativeDefinitions": {
+          "type": "array",
+          "description": "Authoritative definitions block.",
+          "items": {
+            "$ref": "#/$defs/AuthoritativeDefinition"
+          }
+        }
+      }
+    }
+  }
+}

{dataproduct_cli-0.0.1 → dataproduct_cli-0.2.0/dataproduct_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataproduct-cli
-Version: 0.0.1
+Version: 0.2.0
 Summary: The dataproduct CLI is an open source command-line tool for working with data products. It uses data product YAML files following the Open Data Product Standard (ODPS) to lint the definition against the standard and publish it to Entropy Data. 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: Michael Kutz <michael.kutz@entropy-data.com>
 License-Expression: MIT
@@ -44,7 +44,7 @@ Dynamic: license-file
 
 The `dataproduct` CLI is an open-source command-line tool for working with
 **data products** defined with the
-[Open Data Product Standard (ODPS)](https://bitol-io.github.io/open-data-product-standard/v1.0.0/).
+[Open Data Product Standard (ODPS)](https://bitol-io.github.io/open-data-product-standard/v1.1.0/).
 
 It is the data-product sibling of
 [`datacontract-cli`](https://github.com/datacontract/datacontract-cli) (which
@@ -83,8 +83,10 @@ dataproduct lint --output-format junit --output TEST-dataproduct.xml
 dataproduct lint --json-schema ./odps.schema.json  # validate against a custom schema
 ```
 
-Validation is schema-only in 0.1: the data product is checked against the
-bundled ODPS v1.0.0 JSON Schema. Exit code is `0` when valid, `1` otherwise.
+Validation is schema-only: the data product is checked against the bundled
+ODPS JSON Schema matching its `apiVersion` (`v1.1.0`, `v1.0.0`, or `v0.9.0`;
+unknown versions are validated against the latest). Exit code is `0` when
+valid, `1` otherwise.
 
 ### `publish` — publish to Entropy Data
 

{dataproduct_cli-0.0.1 → dataproduct_cli-0.2.0}/dataproduct_cli.egg-info/SOURCES.txt

@@ -26,8 +26,9 @@ dataproduct/model/run.py
 dataproduct/output/__init__.py
 dataproduct/output/output_format.py
 dataproduct/output/result_writer.py
-dataproduct/schemas/odps-1.0.0.init.yaml
 dataproduct/schemas/odps-1.0.0.schema.json
+dataproduct/schemas/odps-1.1.0.init.yaml
+dataproduct/schemas/odps-1.1.0.schema.json
 dataproduct_cli.egg-info/PKG-INFO
 dataproduct_cli.egg-info/SOURCES.txt
 dataproduct_cli.egg-info/dependency_links.txt

{dataproduct_cli-0.0.1 → dataproduct_cli-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dataproduct-cli"
-version = "0.0.1"
+version = "0.2.0"
 description = "The dataproduct CLI is an open source command-line tool for working with data products. It uses data product YAML files following the Open Data Product Standard (ODPS) to lint the definition against the standard and publish it to Entropy Data. 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."
 license = "MIT"
 readme = "README.md"

{dataproduct_cli-0.0.1 → dataproduct_cli-0.2.0}/tests/test_init.py

@@ -12,6 +12,7 @@ def test_init_default_creates_valid_file(tmp_path, monkeypatch):
     assert result.exit_code == 0, result.output
     created = tmp_path / "dataproduct.odps.yaml"
     assert created.exists()
+    assert "apiVersion: v1.1.0" in created.read_text()
 
     # The generated file must pass lint with zero errors.
     run = DataProduct(data_product_file=str(created)).lint()

{dataproduct_cli-0.0.1 → dataproduct_cli-0.2.0}/tests/test_lint.py

@@ -4,6 +4,7 @@ from typer.testing import CliRunner
 
 from dataproduct.cli import app
 from dataproduct.data_product import DataProduct
+from dataproduct.lint.schema import fetch_schema, schema_version_for
 
 runner = CliRunner()
 
@@ -22,6 +23,60 @@ def test_lint_valid():
     assert run.dataProductId == "064c4630-8aad-4dc0-ba95-0f69940e6b18"
 
 
+def test_lint_valid_v1_1_0():
+    run = _lint("valid-dataproduct-v1.1.0.odps.yaml", all_errors=True)
+    assert run.result == "passed", run.checks
+    assert run.checks[0].name == "Data product is valid against ODPS v1.1.0"
+
+
+def test_lint_names_the_schema_that_ran():
+    run = _lint("valid-dataproduct.odps.yaml")
+    assert run.result == "passed", run.checks
+    assert run.checks[0].name == "Data product is valid against ODPS v1.0.0"
+
+
+def test_lint_names_no_version_for_custom_schema():
+    run = DataProduct(
+        data_product_file=str(FIXTURES / "valid-dataproduct.odps.yaml"),
+        schema_location=str(BUNDLED_SCHEMA),
+    ).lint()
+    assert run.checks[0].name == "Data product is syntactically valid"
+
+
+def test_lint_v1_1_0_status_is_optional():
+    run = _lint("missing-status-v1.1.0.odps.yaml")
+    assert run.result == "passed", run.checks
+
+
+def test_lint_v1_1_0_fields_rejected_under_v1_0_0():
+    run = _lint("v1.1.0-fields-in-v1.0.0.odps.yaml")
+    assert run.result == "failed"
+    assert run.checks[0].name == "Check that data product is valid against ODPS v1.0.0"
+    assert "type" in (run.checks[0].reason or "")
+
+
+def test_lint_unknown_api_version_reported():
+    run = _lint("multiple-errors.odps.yaml", all_errors=True)
+    assert run.result == "failed"
+    assert all(c.name == "Check that data product is valid against ODPS v1.1.0" for c in run.checks)
+    assert "apiVersion" in [c.field for c in run.checks]
+
+
+def test_schema_version_selected_by_api_version():
+    assert schema_version_for("v1.1.0") == "1.1.0"
+    assert schema_version_for("v1.0.0") == "1.0.0"
+    assert schema_version_for("v0.9.0") == "1.0.0"
+    assert schema_version_for(None) == "1.1.0"
+    assert schema_version_for("v9.9.9") == "1.1.0"
+    assert schema_version_for(["not", "a", "string"]) == "1.1.0"
+
+
+def test_fetch_bundled_schema_per_version():
+    assert "status" in fetch_schema(schema_version="1.0.0")["required"]
+    assert "status" not in fetch_schema(schema_version="1.1.0")["required"]
+    assert fetch_schema()["properties"]["apiVersion"]["default"] == "v1.1.0"
+
+
 def test_lint_valid_cli_exit_zero():
     result = runner.invoke(app, ["lint", str(FIXTURES / "valid-dataproduct.odps.yaml")])
     assert result.exit_code == 0, result.output

dataproduct_cli-0.0.1/dataproduct/lint/schema.py

@@ -1,44 +0,0 @@
-import importlib.resources as resources
-import json
-import logging
-import os
-from pathlib import Path
-from typing import Any, Dict, Union
-
-import requests
-
-from dataproduct.model.exceptions import DataProductException
-from dataproduct.model.run import ResultEnum
-
-DEFAULT_DATA_PRODUCT_SCHEMA = "odps-1.0.0.schema.json"
-
-
-def fetch_schema(location: Union[str, Path] = None) -> Dict[str, Any]:
-    """Fetch the ODPS JSON Schema to validate against.
-
-    ``None`` uses the bundled ODPS v1.0.0 schema; otherwise ``location`` is a URL
-    or local path.
-    """
-    if location is None:
-        logging.info("Use default bundled schema " + DEFAULT_DATA_PRODUCT_SCHEMA)
-        schemas = resources.files("dataproduct")
-        schema_file = schemas.joinpath("schemas", DEFAULT_DATA_PRODUCT_SCHEMA)
-        with schema_file.open("r") as file:
-            return json.load(file)
-
-    location_str = str(location)
-    if location_str.startswith("http://") or location_str.startswith("https://"):
-        logging.debug(f"Downloading schema from {location_str}")
-        response = requests.get(location_str)
-        return response.json()
-
-    if not os.path.exists(location_str):
-        raise DataProductException(
-            type="lint",
-            name=f"Reading schema from {location_str}",
-            reason=f"The file '{location_str}' does not exist.",
-            result=ResultEnum.error,
-        )
-    logging.debug(f"Loading JSON schema locally at {location_str}")
-    with open(location_str, "r") as file:
-        return json.load(file)