datacontract-cli 0.10.8__py3-none-any.whl → 0.10.10__py3-none-any.whl

datacontract/catalog/catalog.py

@@ -10,8 +10,10 @@ from datacontract.export.html_export import get_version
 from datacontract.model.data_contract_specification import DataContractSpecification
 
 
-def create_data_contract_html(contracts, file: Path, path: Path):
-    data_contract = DataContract(data_contract_file=f"{file.absolute()}", inline_definitions=True, inline_quality=True)
+def create_data_contract_html(contracts, file: Path, path: Path, schema: str):
+    data_contract = DataContract(
+        data_contract_file=f"{file.absolute()}", inline_definitions=True, inline_quality=True, schema_location=schema
+    )
     html = data_contract.export(export_format="html")
     spec = data_contract.get_data_contract_specification()
     file_without_suffix = file.with_suffix(".html")

datacontract/cli.py

@@ -1,4 +1,3 @@
-from enum import Enum
 from importlib import metadata
 from pathlib import Path
 from typing import Iterable, Optional
@@ -16,9 +15,12 @@ from typing_extensions import Annotated
 from datacontract import web
 from datacontract.catalog.catalog import create_index_html, create_data_contract_html
 from datacontract.data_contract import DataContract, ExportFormat
+from datacontract.imports.importer import ImportFormat
 from datacontract.init.download_datacontract_file import download_datacontract_file, FileExistsException
 from datacontract.publish.publish import publish_to_datamesh_manager
 
+DEFAULT_DATA_CONTRACT_SCHEMA_URL = "https://datacontract.com/datacontract.schema.json"
+
 console = Console()
 
 
@@ -86,7 +88,7 @@ def lint(
     ] = "datacontract.yaml",
     schema: Annotated[
         str, typer.Option(help="The location (url or path) of the Data Contract Specification JSON Schema")
-    ] = "https://datacontract.com/datacontract.schema.json",
+    ] = DEFAULT_DATA_CONTRACT_SCHEMA_URL,
 ):
     """
     Validate that the datacontract.yaml is correctly formatted.
@@ -102,7 +104,7 @@ def test(
     ] = "datacontract.yaml",
     schema: Annotated[
         str, typer.Option(help="The location (url or path) of the Data Contract Specification JSON Schema")
-    ] = "https://datacontract.com/datacontract.schema.json",
+    ] = DEFAULT_DATA_CONTRACT_SCHEMA_URL,
     server: Annotated[
         str,
         typer.Option(
@@ -177,12 +179,15 @@ def export(
     location: Annotated[
         str, typer.Argument(help="The location (url or path) of the data contract yaml.")
     ] = "datacontract.yaml",
+    schema: Annotated[
+        str, typer.Option(help="The location (url or path) of the Data Contract Specification JSON Schema")
+    ] = DEFAULT_DATA_CONTRACT_SCHEMA_URL,
 ):
     """
     Convert data contract to a specific format. console.prints to stdout.
     """
     # TODO exception handling
-    result = DataContract(data_contract_file=location, server=server).export(
+    result = DataContract(data_contract_file=location, schema_location=schema, server=server).export(
         export_format=format,
         model=model,
         server=server,
@@ -198,16 +203,6 @@ def export(
         console.print(f"Written result to {output}")
 
 
-class ImportFormat(str, Enum):
-    sql = "sql"
-    avro = "avro"
-    glue = "glue"
-    bigquery = "bigquery"
-    jsonschema = "jsonschema"
-    odcs="odcs"
-    unity = "unity"
-
-
 @app.command(name="import")
 def import_(
     format: Annotated[ImportFormat, typer.Option(help="The format of the source file.")],
@@ -228,12 +223,29 @@ def import_(
             help="List of table ids to import from the bigquery API (repeat for multiple table ids, leave empty for all tables in the dataset)."
         ),
     ] = None,
-    unity_table_full_name: Annotated[Optional[str], typer.Option(help="Full name of a table in the unity catalog")] = None,
+    unity_table_full_name: Annotated[
+        Optional[str], typer.Option(help="Full name of a table in the unity catalog")
+    ] = None,
+    dbt_model: Annotated[
+        Optional[List[str]],
+        typer.Option(
+            help="List of models names to import from the dbt manifest file (repeat for multiple models names, leave empty for all models in the dataset)."
+        ),
+    ] = None,
 ):
     """
     Create a data contract from the given source location. Prints to stdout.
     """
-    result = DataContract().import_from_source(format, source, glue_table, bigquery_table, bigquery_project, bigquery_dataset, unity_table_full_name)
+    result = DataContract().import_from_source(
+        format=format,
+        source=source,
+        glue_table=glue_table,
+        bigquery_table=bigquery_table,
+        bigquery_project=bigquery_project,
+        bigquery_dataset=bigquery_dataset,
+        unity_table_full_name=unity_table_full_name,
+        dbt_model=dbt_model,
+    )
     console.print(result.to_yaml())
 
 
@@ -242,12 +254,15 @@ def publish(
     location: Annotated[
         str, typer.Argument(help="The location (url or path) of the data contract yaml.")
     ] = "datacontract.yaml",
+    schema: Annotated[
+        str, typer.Option(help="The location (url or path) of the Data Contract Specification JSON Schema")
+    ] = DEFAULT_DATA_CONTRACT_SCHEMA_URL,
 ):
     """
     Publish the data contract to the Data Mesh Manager.
     """
     publish_to_datamesh_manager(
-        data_contract=DataContract(data_contract_file=location),
+        data_contract=DataContract(data_contract_file=location, schema_location=schema),
     )
 
 
@@ -257,6 +272,9 @@ def catalog(
         Optional[str], typer.Option(help="Glob pattern for the data contract files to include in the catalog.")
     ] = "*.yaml",
     output: Annotated[Optional[str], typer.Option(help="Output directory for the catalog html files.")] = "catalog/",
+    schema: Annotated[
+        str, typer.Option(help="The location (url or path) of the Data Contract Specification JSON Schema")
+    ] = DEFAULT_DATA_CONTRACT_SCHEMA_URL,
 ):
     """
     Create an html catalog of data contracts.
@@ -268,7 +286,7 @@ def catalog(
     contracts = []
     for file in Path().glob(files):
         try:
-            create_data_contract_html(contracts, file, path)
+            create_data_contract_html(contracts, file, path, schema)
         except Exception as e:
             console.print(f"Skipped {file} due to error: {e}")
 

datacontract/data_contract.py

@@ -4,7 +4,9 @@ import tempfile
 import typing
 
 import yaml
-from pyspark.sql import SparkSession
+
+if typing.TYPE_CHECKING:
+    from pyspark.sql import SparkSession
 
 from datacontract.breaking.breaking import models_breaking_changes, quality_breaking_changes
 from datacontract.engines.datacontract.check_that_datacontract_contains_valid_servers_configuration import (
@@ -14,13 +16,8 @@ from datacontract.engines.fastjsonschema.check_jsonschema import check_jsonschem
 from datacontract.engines.soda.check_soda_execute import check_soda_execute
 from datacontract.export.exporter import ExportFormat
 from datacontract.export.exporter_factory import exporter_factory
-from datacontract.imports.avro_importer import import_avro
-from datacontract.imports.bigquery_importer import import_bigquery_from_api, import_bigquery_from_json
-from datacontract.imports.glue_importer import import_glue
-from datacontract.imports.jsonschema_importer import import_jsonschema
-from datacontract.imports.odcs_importer import import_odcs
-from datacontract.imports.sql_importer import import_sql
-from datacontract.imports.unity_importer import import_unity_from_json, import_unity_from_api
+from datacontract.imports.importer_factory import importer_factory
+
 from datacontract.integration.publish_datamesh_manager import publish_datamesh_manager
 from datacontract.integration.publish_opentelemetry import publish_opentelemetry
 from datacontract.lint import resolve
@@ -48,7 +45,7 @@ class DataContract:
         examples: bool = False,
         publish_url: str = None,
         publish_to_opentelemetry: bool = False,
-        spark: SparkSession = None,
+        spark: "SparkSession" = None,
         inline_definitions: bool = False,
         inline_quality: bool = False,
     ):
@@ -301,17 +298,12 @@ class DataContract:
             inline_quality=self._inline_quality,
         )
 
-    def export(
-        self,
-        export_format: ExportFormat,
-        model: str = "all",
-        sql_server_type: str = "auto",
-        **kwargs,
-    ) -> str:
+    def export(self, export_format: ExportFormat, model: str = "all", sql_server_type: str = "auto", **kwargs) -> str:
         data_contract = resolve.resolve_data_contract(
             self._data_contract_file,
             self._data_contract_str,
             self._data_contract,
+            schema_location=self._schema_location,
             inline_definitions=True,
             inline_quality=True,
         )
@@ -325,42 +317,10 @@ class DataContract:
         )
 
     def import_from_source(
-        self,
-        format: str,
-        source: typing.Optional[str] = None,
-        glue_tables: typing.Optional[typing.List[str]] = None,
-        bigquery_tables: typing.Optional[typing.List[str]] = None,
-        bigquery_project: typing.Optional[str] = None,
-        bigquery_dataset: typing.Optional[str] = None,
-        unity_table_full_name: typing.Optional[str] = None
+        self, format: str, source: typing.Optional[str] = None, **kwargs
     ) -> DataContractSpecification:
-        data_contract_specification = DataContract.init()
-
-        if format == "sql":
-            data_contract_specification = import_sql(data_contract_specification, format, source)
-        elif format == "avro":
-            data_contract_specification = import_avro(data_contract_specification, source)
-        elif format == "glue":
-            data_contract_specification = import_glue(data_contract_specification, source, glue_tables)
-        elif format == "jsonschema":
-            data_contract_specification = import_jsonschema(data_contract_specification, source)
-        elif format == "bigquery":
-            if source is not None:
-                data_contract_specification = import_bigquery_from_json(data_contract_specification, source)
-            else:
-                data_contract_specification = import_bigquery_from_api(
-                    data_contract_specification, bigquery_tables, bigquery_project, bigquery_dataset
-                )
-        elif format == "odcs":
-            data_contract_specification = import_odcs(data_contract_specification, source)
-        elif format == "unity":
-            if source is not None:
-                data_contract_specification = import_unity_from_json(data_contract_specification, source)
-            else:
-                data_contract_specification = import_unity_from_api(
-                    data_contract_specification, unity_table_full_name
-                )
-        else:
-            print(f"Import format {format} not supported.")
+        data_contract_specification_initial = DataContract.init()
 
-        return data_contract_specification
+        return importer_factory.create(format).import_source(
+            data_contract_specification=data_contract_specification_initial, source=source, import_args=kwargs
+        )

datacontract/engines/soda/check_soda_execute.py

@@ -1,6 +1,9 @@
 import logging
+import typing
+
+if typing.TYPE_CHECKING:
+    from pyspark.sql import SparkSession
 
-from pyspark.sql import SparkSession
 from soda.scan import Scan
 
 from datacontract.engines.soda.connections.bigquery import to_bigquery_soda_configuration
@@ -10,13 +13,14 @@ from datacontract.engines.soda.connections.kafka import create_spark_session, re
 from datacontract.engines.soda.connections.postgres import to_postgres_soda_configuration
 from datacontract.engines.soda.connections.snowflake import to_snowflake_soda_configuration
 from datacontract.engines.soda.connections.sqlserver import to_sqlserver_soda_configuration
+from datacontract.engines.soda.connections.trino import to_trino_soda_configuration
 from datacontract.export.sodacl_converter import to_sodacl_yaml
 from datacontract.model.data_contract_specification import DataContractSpecification, Server
 from datacontract.model.run import Run, Check, Log
 
 
 def check_soda_execute(
-    run: Run, data_contract: DataContractSpecification, server: Server, spark: SparkSession, tmp_dir
+    run: Run, data_contract: DataContractSpecification, server: Server, spark: "SparkSession", tmp_dir
 ):
     if data_contract is None:
         run.log_warn("Cannot run engine soda-core, as data contract is invalid")
@@ -85,6 +89,10 @@ def check_soda_execute(
         soda_configuration_str = to_sqlserver_soda_configuration(server)
         scan.add_configuration_yaml_str(soda_configuration_str)
         scan.set_data_source_name(server.type)
+    elif server.type == "trino":
+        soda_configuration_str = to_trino_soda_configuration(server)
+        scan.add_configuration_yaml_str(soda_configuration_str)
+        scan.set_data_source_name(server.type)
 
     else:
         run.checks.append(

datacontract/engines/soda/connections/duckdb.py

@@ -50,6 +50,10 @@ def get_duckdb_connection(data_contract, server, run: Run):
                 )
         elif server.format == "delta":
             if server.type == "azure":
+                # After switching to native delta table support
+                # in https://github.com/datacontract/datacontract-cli/issues/258,
+                # azure storage should also work
+                # https://github.com/duckdb/duckdb_delta/issues/21
                 raise NotImplementedError("Support for Delta Tables on Azure Storage is not implemented yet")
 
             storage_options = {
@@ -80,6 +84,7 @@ def setup_s3_connection(con, server):
     s3_region = os.getenv("DATACONTRACT_S3_REGION")
     s3_access_key_id = os.getenv("DATACONTRACT_S3_ACCESS_KEY_ID")
     s3_secret_access_key = os.getenv("DATACONTRACT_S3_SECRET_ACCESS_KEY")
+    s3_session_token = os.getenv("DATACONTRACT_S3_SESSION_TOKEN")
     s3_endpoint = "s3.amazonaws.com"
     use_ssl = "true"
     url_style = "vhost"
@@ -90,18 +95,33 @@ def setup_s3_connection(con, server):
             url_style = "path"
 
     if s3_access_key_id is not None:
-        con.sql(f"""
-            CREATE OR REPLACE SECRET s3_secret (
-                TYPE S3,
-                PROVIDER CREDENTIAL_CHAIN,
-                REGION '{s3_region}',
-                KEY_ID '{s3_access_key_id}',
-                SECRET '{s3_secret_access_key}',
-                ENDPOINT '{s3_endpoint}',
-                USE_SSL '{use_ssl}',
-                URL_STYLE '{url_style}'
-            );
-        """)
+        if s3_session_token is not None:
+            con.sql(f"""
+                CREATE OR REPLACE SECRET s3_secret (
+                    TYPE S3,
+                    PROVIDER CREDENTIAL_CHAIN,
+                    REGION '{s3_region}',
+                    KEY_ID '{s3_access_key_id}',
+                    SECRET '{s3_secret_access_key}',
+                    SESSION_TOKEN '{s3_session_token}',
+                    ENDPOINT '{s3_endpoint}',
+                    USE_SSL '{use_ssl}',
+                    URL_STYLE '{url_style}'
+                );
+            """)
+        else:
+            con.sql(f"""
+                CREATE OR REPLACE SECRET s3_secret (
+                    TYPE S3,
+                    PROVIDER CREDENTIAL_CHAIN,
+                    REGION '{s3_region}',
+                    KEY_ID '{s3_access_key_id}',
+                    SECRET '{s3_secret_access_key}',
+                    ENDPOINT '{s3_endpoint}',
+                    USE_SSL '{use_ssl}',
+                    URL_STYLE '{url_style}'
+                );
+            """)
 
     #     con.sql(f"""
     #                 SET s3_region = '{s3_region}';

datacontract/engines/soda/connections/trino.py

@@ -0,0 +1,26 @@
+import os
+
+import yaml
+
+
+def to_trino_soda_configuration(server):
+    password = os.getenv("DATACONTRACT_TRINO_PASSWORD")
+    username = os.getenv("DATACONTRACT_TRINO_USERNAME")
+
+    data_source = {
+        "type": "trino",
+        "host": server.host,
+        "port": str(server.port),
+        "username": username,
+        "password": password,
+        "catalog": server.catalog,
+        "schema": server.schema_,
+    }
+
+    if password is None or password == "":
+        data_source["auth_type"] = "NoAuthentication"  # default is BasicAuthentication
+
+    soda_configuration = {f"data_source {server.type}": data_source}
+
+    soda_configuration_str = yaml.dump(soda_configuration)
+    return soda_configuration_str

datacontract/export/avro_converter.py

@@ -65,7 +65,7 @@ def to_avro_type(field: Field, field_name: str) -> str | dict:
             if field.config["avroLogicalType"] in ["time-millis", "date"]:
                 return {"type": "int", "logicalType": field.config["avroLogicalType"]}
         if "avroType" in field.config:
-            return field.config["avroLogicalType"]
+            return field.config["avroType"]
 
     if field.type is None:
         return "null"

datacontract/export/exporter.py

@@ -34,10 +34,11 @@ class ExportFormat(str, Enum):
     go = "go"
     bigquery = "bigquery"
     dbml = "dbml"
+    spark = "spark"
 
     @classmethod
-    def get_formats(cls):
-        return cls.__dict__
+    def get_suported_formats(cls):
+        return list(map(lambda c: c.value, cls))
 
 
 def _check_models_for_export(

datacontract/export/exporter_factory.py

@@ -1,52 +1,145 @@
-from datacontract.export.avro_idl_converter import AvroIdlExporter
-from datacontract.export.bigquery_converter import BigQueryExporter
-from datacontract.export.dbml_converter import DbmlExporter
-from datacontract.export.dbt_converter import DbtExporter, DbtSourceExporter, DbtStageExporter
-from datacontract.export.avro_converter import AvroExporter
+import importlib
+import sys
 from datacontract.export.exporter import ExportFormat, Exporter
-from datacontract.export.go_converter import GoExporter
-from datacontract.export.great_expectations_converter import GreateExpectationsExporter
-from datacontract.export.html_export import HtmlExporter
-from datacontract.export.jsonschema_converter import JsonSchemaExporter
-from datacontract.export.odcs_converter import OdcsExporter
-from datacontract.export.protobuf_converter import ProtoBufExporter
-from datacontract.export.pydantic_converter import PydanticExporter
-from datacontract.export.rdf_converter import RdfExporter
-from datacontract.export.sodacl_converter import SodaExporter
-from datacontract.export.sql_converter import SqlExporter, SqlQueryExporter
-from datacontract.export.terraform_converter import TerraformExporter
 
 
 class ExporterFactory:
     def __init__(self):
         self.dict_exporter = {}
+        self.dict_lazy_exporter = {}
 
-    def register_exporter(self, name, exporter):
+    def register_exporter(self, name: str, exporter: Exporter):
         self.dict_exporter.update({name: exporter})
 
+    def register_lazy_exporter(self, name: str, module_path: str, class_name: str):
+        self.dict_lazy_exporter.update({name: (module_path, class_name)})
+
     def create(self, name) -> Exporter:
-        if name not in self.dict_exporter.keys():
-            raise ValueError(f"Export format {name} not supported.")
-        return self.dict_exporter[name](name)
+        exporters = self.dict_exporter.copy()
+        exporters.update(self.dict_lazy_exporter.copy())
+        if name not in exporters.keys():
+            raise ValueError(f"The '{name}' format is not supported.")
+        exporter_class = exporters[name]
+        if type(exporters[name]) is tuple:
+            exporter_class = load_module_class(module_path=exporters[name][0], class_name=exporters[name][1])
+        if not exporter_class:
+            raise ValueError(f"Module {name} could not be loaded.")
+        return exporter_class(name)
+
+
+def import_module(module_path):
+    if importlib.util.find_spec(module_path) is not None:
+        try:
+            module = importlib.import_module(module_path)
+        except ModuleNotFoundError:
+            return None
+        sys.modules[module_path] = module
+        return module
+
+
+def load_module_class(module_path, class_name):
+    module = import_module(module_path)
+    if not module:
+        return None
+    return getattr(module, class_name)
 
 
 exporter_factory = ExporterFactory()
-exporter_factory.register_exporter(ExportFormat.avro, AvroExporter)
-exporter_factory.register_exporter(ExportFormat.avro_idl, AvroIdlExporter)
-exporter_factory.register_exporter(ExportFormat.bigquery, BigQueryExporter)
-exporter_factory.register_exporter(ExportFormat.dbml, DbmlExporter)
-exporter_factory.register_exporter(ExportFormat.rdf, RdfExporter)
-exporter_factory.register_exporter(ExportFormat.dbt, DbtExporter)
-exporter_factory.register_exporter(ExportFormat.dbt_sources, DbtSourceExporter)
-exporter_factory.register_exporter(ExportFormat.dbt_staging_sql, DbtStageExporter)
-exporter_factory.register_exporter(ExportFormat.jsonschema, JsonSchemaExporter)
-exporter_factory.register_exporter(ExportFormat.odcs, OdcsExporter)
-exporter_factory.register_exporter(ExportFormat.go, GoExporter)
-exporter_factory.register_exporter(ExportFormat.great_expectations, GreateExpectationsExporter)
-exporter_factory.register_exporter(ExportFormat.html, HtmlExporter)
-exporter_factory.register_exporter(ExportFormat.protobuf, ProtoBufExporter)
-exporter_factory.register_exporter(ExportFormat.pydantic_model, PydanticExporter)
-exporter_factory.register_exporter(ExportFormat.sodacl, SodaExporter)
-exporter_factory.register_exporter(ExportFormat.sql, SqlExporter)
-exporter_factory.register_exporter(ExportFormat.sql_query, SqlQueryExporter)
-exporter_factory.register_exporter(ExportFormat.terraform, TerraformExporter)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.avro, module_path="datacontract.export.avro_converter", class_name="AvroExporter"
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.avro_idl,
+    module_path="datacontract.export.avro_idl_converter",
+    class_name="AvroIdlExporter",
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.bigquery,
+    module_path="datacontract.export.bigquery_converter",
+    class_name="BigQueryExporter",
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.dbml, module_path="datacontract.export.dbml_converter", class_name="DbmlExporter"
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.rdf, module_path="datacontract.export.rdf_converter", class_name="RdfExporter"
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.dbt, module_path="datacontract.export.dbt_converter", class_name="DbtExporter"
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.dbt_sources,
+    module_path="datacontract.export.dbt_converter",
+    class_name="DbtSourceExporter",
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.dbt_staging_sql,
+    module_path="datacontract.export.dbt_converter",
+    class_name="DbtStageExporter",
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.jsonschema,
+    module_path="datacontract.export.jsonschema_converter",
+    class_name="JsonSchemaExporter",
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.odcs, module_path="datacontract.export.odcs_converter", class_name="OdcsExporter"
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.go, module_path="datacontract.export.go_converter", class_name="GoExporter"
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.great_expectations,
+    module_path="datacontract.export.great_expectations_converter",
+    class_name="GreateExpectationsExporter",
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.html, module_path="datacontract.export.html_export", class_name="HtmlExporter"
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.protobuf,
+    module_path="datacontract.export.protobuf_converter",
+    class_name="ProtoBufExporter",
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.pydantic_model,
+    module_path="datacontract.export.pydantic_converter",
+    class_name="PydanticExporter",
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.sodacl, module_path="datacontract.export.sodacl_converter", class_name="SodaExporter"
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.sql, module_path="datacontract.export.sql_converter", class_name="SqlExporter"
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.sql_query, module_path="datacontract.export.sql_converter", class_name="SqlQueryExporter"
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.terraform,
+    module_path="datacontract.export.terraform_converter",
+    class_name="TerraformExporter",
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.spark, module_path="datacontract.export.spark_converter", class_name="SparkExporter"
+)

datacontract/export/jsonschema_converter.py

@@ -58,27 +58,27 @@ def to_property(field: Field) -> dict:
         property["pattern"] = field.pattern
     if field.enum:
         property["enum"] = field.enum
-    if field.minLength:
+    if field.minLength is not None:
         property["minLength"] = field.minLength
-    if field.maxLength:
+    if field.maxLength is not None:
         property["maxLength"] = field.maxLength
     if field.title:
         property["title"] = field.title
     if field.description:
         property["description"] = field.description
-    if field.exclusiveMinimum:
+    if field.exclusiveMinimum is not None:
         property["exclusiveMinimum"] = field.exclusiveMinimum
-    if field.exclusiveMaximum:
+    if field.exclusiveMaximum is not None:
         property["exclusiveMaximum"] = field.exclusiveMaximum
-    if field.minimum:
+    if field.minimum is not None:
         property["minimum"] = field.minimum
-    if field.maximum:
+    if field.maximum is not None:
         property["maximum"] = field.maximum
     if field.tags:
         property["tags"] = field.tags
     if field.pii:
         property["pii"] = field.pii
-    if field.classification:
+    if field.classification is not None:
         property["classification"] = field.classification
 
     # TODO: all constraints