datacontract-cli 0.10.16__py3-none-any.whl → 0.10.18__py3-none-any.whl

datacontract/breaking/breaking_rules.py

@@ -42,6 +42,10 @@ class BreakingRules:
     field_primary_removed = Severity.WARNING
     field_primary_updated = Severity.WARNING
 
+    field_primary_key_added = Severity.WARNING
+    field_primary_key_removed = Severity.WARNING
+    field_primary_key_updated = Severity.WARNING
+
     field_references_added = Severity.WARNING
     field_references_removed = Severity.WARNING
     field_references_updated = Severity.WARNING

datacontract/cli.py

@@ -132,13 +132,11 @@ def test(
         typer.Option(help="Run the schema and quality tests on the example data within the data contract."),
     ] = None,
     publish: Annotated[str, typer.Option(help="The url to publish the results after the test")] = None,
-    publish_to_opentelemetry: Annotated[
-        bool,
-        typer.Option(
-            help="Publish the results to opentelemetry. Use environment variables to configure the OTLP endpoint, headers, etc."
-        ),
-    ] = False,
     logs: Annotated[bool, typer.Option(help="Print logs")] = False,
+    ssl_verification: Annotated[
+        bool,
+        typer.Option(help="SSL verification when publishing the test results."),
+    ] = True,
 ):
     """
     Run schema and quality tests on configured servers.
@@ -150,7 +148,6 @@ def test(
         data_contract_file=location,
         schema_location=schema,
         publish_url=publish,
-        publish_to_opentelemetry=publish_to_opentelemetry,
         server=server,
         examples=examples,
     ).test()
@@ -280,6 +277,14 @@ def import_(
         Optional[str],
         typer.Option(help="Table name to assign to the model created from the Iceberg schema."),
     ] = None,
+    template: Annotated[
+        Optional[str],
+        typer.Option(help="The location (url or path) of the Data Contract Specification Template"),
+    ] = None,
+    schema: Annotated[
+        str,
+        typer.Option(help="The location (url or path) of the Data Contract Specification JSON Schema"),
+    ] = DEFAULT_DATA_CONTRACT_SCHEMA_URL,
 ):
     """
     Create a data contract from the given source location. Saves to file specified by `output` option if present, otherwise prints to stdout.
@@ -287,6 +292,8 @@ def import_(
     result = DataContract().import_from_source(
         format=format,
         source=source,
+        template=template,
+        schema=schema,
         glue_table=glue_table,
         bigquery_table=bigquery_table,
         bigquery_project=bigquery_project,
@@ -315,6 +322,10 @@ def publish(
         str,
         typer.Option(help="The location (url or path) of the Data Contract Specification JSON Schema"),
     ] = DEFAULT_DATA_CONTRACT_SCHEMA_URL,
+    ssl_verification: Annotated[
+        bool,
+        typer.Option(help="SSL verification when publishing the data contract."),
+    ] = True,
 ):
     """
     Publish the data contract to the Data Mesh Manager.
@@ -323,6 +334,7 @@ def publish(
         data_contract_specification=DataContract(
             data_contract_file=location, schema_location=schema
         ).get_data_contract_specification(),
+        ssl_verification=ssl_verification,
     )
 
 
@@ -447,6 +459,18 @@ def _handle_result(run):
         console.print(
             f"🟢 data contract is valid. Run {len(run.checks)} checks. Took {(run.timestampEnd - run.timestampStart).total_seconds()} seconds."
         )
+    elif run.result == "warning":
+        console.print("🟠 data contract has warnings. Found the following warnings:")
+        i = 1
+        for check in run.checks:
+            if check.result != "passed":
+                field = to_field(run, check)
+                if field:
+                    field = field + " "
+                else:
+                    field = ""
+                console.print(f"{i}) {field}{check.name}: {check.reason}")
+                i += 1
     else:
         console.print("🔴 data contract is invalid, found the following errors:")
         i = 1

datacontract/data_contract.py

@@ -23,7 +23,6 @@ from datacontract.export.exporter import ExportFormat
 from datacontract.export.exporter_factory import exporter_factory
 from datacontract.imports.importer_factory import importer_factory
 from datacontract.integration.datamesh_manager import publish_test_results_to_datamesh_manager
-from datacontract.integration.opentelemetry import publish_test_results_to_opentelemetry
 from datacontract.lint import resolve
 from datacontract.lint.linters.description_linter import DescriptionLinter
 from datacontract.lint.linters.example_model_linter import ExampleModelLinter
@@ -37,6 +36,8 @@ from datacontract.model.data_contract_specification import DataContractSpecifica
 from datacontract.model.exceptions import DataContractException
 from datacontract.model.run import Check, Run
 
+DEFAULT_DATA_CONTRACT_TEMPLATE_URL = "https://datacontract.com/datacontract.init.yaml"
+
 
 class DataContract:
     def __init__(
@@ -48,7 +49,6 @@ class DataContract:
         server: str = None,
         examples: bool = False,
         publish_url: str = None,
-        publish_to_opentelemetry: bool = False,
         spark: "SparkSession" = None,
         inline_definitions: bool = True,
         inline_quality: bool = True,
@@ -60,7 +60,6 @@ class DataContract:
         self._server = server
         self._examples = examples
         self._publish_url = publish_url
-        self._publish_to_opentelemetry = publish_to_opentelemetry
         self._spark = spark
         self._inline_definitions = inline_definitions
         self._inline_quality = inline_quality
@@ -75,8 +74,10 @@ class DataContract:
         }
 
     @classmethod
-    def init(cls, template: str = "https://datacontract.com/datacontract.init.yaml") -> DataContractSpecification:
-        return resolve.resolve_data_contract(data_contract_location=template)
+    def init(
+        cls, template: str = DEFAULT_DATA_CONTRACT_TEMPLATE_URL, schema: typing.Optional[str] = None
+    ) -> DataContractSpecification:
+        return resolve.resolve_data_contract(data_contract_location=template, schema_location=schema)
 
     def lint(self, enabled_linters: typing.Union[str, set[str]] = "all") -> Run:
         """Lint the data contract by deserializing the contract and checking the schema, as well as calling the configured linters.
@@ -232,9 +233,6 @@ class DataContract:
         if self._publish_url is not None:
             publish_test_results_to_datamesh_manager(run, self._publish_url)
 
-        if self._publish_to_opentelemetry:
-            publish_test_results_to_opentelemetry(run)
-
         return run
 
     def _get_examples_server(self, data_contract, run, tmp_dir):
@@ -347,9 +345,15 @@ class DataContract:
         )
 
     def import_from_source(
-        self, format: str, source: typing.Optional[str] = None, **kwargs
+        self,
+        format: str,
+        source: typing.Optional[str] = None,
+        template: typing.Optional[str] = None,
+        schema: typing.Optional[str] = None,
+        **kwargs,
     ) -> DataContractSpecification:
-        data_contract_specification_initial = DataContract.init()
+        template = DEFAULT_DATA_CONTRACT_TEMPLATE_URL if template is None else template
+        data_contract_specification_initial = DataContract.init(template=template, schema=schema)
 
         return importer_factory.create(format).import_source(
             data_contract_specification=data_contract_specification_initial, source=source, import_args=kwargs

datacontract/engines/fastjsonschema/check_jsonschema.py

@@ -11,7 +11,7 @@ from datacontract.engines.fastjsonschema.s3.s3_read_files import yield_s3_files
 from datacontract.export.jsonschema_converter import to_jsonschema
 from datacontract.model.data_contract_specification import DataContractSpecification, Server
 from datacontract.model.exceptions import DataContractException
-from datacontract.model.run import Check, Run
+from datacontract.model.run import Check, ResultEnum, Run
 
 # Thread-safe cache for primaryKey fields.
 _primary_key_cache = {}
@@ -256,18 +256,29 @@ def check_jsonschema(run: Run, data_contract: DataContractSpecification, server:
                     type="schema",
                     name="Check that JSON has valid schema",
                     model=model_name,
-                    result="info",
+                    result=ResultEnum.info,
                     reason="JSON Schema check skipped for GCS, as GCS is currently not supported",
                     engine="jsonschema",
                 )
             )
+        elif server.type == "azure":
+            run.checks.append(
+                Check(
+                    type="schema",
+                    name="Check that JSON has valid schema",
+                    model=model_name,
+                    result=ResultEnum.info,
+                    reason="JSON Schema check skipped for azure, as azure is currently not supported",
+                    engine="jsonschema",
+                )
+            )
         else:
             run.checks.append(
                 Check(
                     type="schema",
                     name="Check that JSON has valid schema",
                     model=model_name,
-                    result="warn",
+                    result=ResultEnum.warning,
                     reason=f"Server type {server.type} not supported",
                     engine="jsonschema",
                 )
@@ -279,7 +290,7 @@ def check_jsonschema(run: Run, data_contract: DataContractSpecification, server:
                 type="schema",
                 name="Check that JSON has valid schema",
                 model=model_name,
-                result="passed",
+                result=ResultEnum.passed,
                 reason="All JSON entries are valid.",
                 engine="jsonschema",
             )

datacontract/engines/soda/check_soda_execute.py

@@ -1,7 +1,5 @@
 import logging
 
-from soda.scan import Scan
-
 from datacontract.engines.soda.connections.bigquery import to_bigquery_soda_configuration
 from datacontract.engines.soda.connections.databricks import to_databricks_soda_configuration
 from datacontract.engines.soda.connections.duckdb import get_duckdb_connection
@@ -16,6 +14,11 @@ from datacontract.model.run import Check, Log, ResultEnum, Run
 
 
 def check_soda_execute(run: Run, data_contract: DataContractSpecification, server: Server, spark, tmp_dir):
+    from soda.common.config_helper import ConfigHelper
+
+    ConfigHelper.get_instance().upsert_value("send_anonymous_usage_stats", False)
+    from soda.scan import Scan
+
     if data_contract is None:
         run.log_warn("Cannot run engine soda-core, as data contract is invalid")
         return
@@ -25,6 +28,7 @@ def check_soda_execute(run: Run, data_contract: DataContractSpecification, serve
 
     if server.type in ["s3", "gcs", "azure", "local"]:
         if server.format in ["json", "parquet", "csv", "delta"]:
+            run.log_info(f"Configuring engine soda-core to connect to {server.type} {server.format} with duckdb")
             con = get_duckdb_connection(data_contract, server, run)
             scan.add_duckdb_connection(duckdb_connection=con, data_source_name=server.type)
             scan.set_data_source_name(server.type)
@@ -54,11 +58,12 @@ def check_soda_execute(run: Run, data_contract: DataContractSpecification, serve
         scan.set_data_source_name(server.type)
     elif server.type == "databricks":
         if spark is not None:
-            logging.info("Use Spark to connect to data source")
+            run.log_info("Connecting to databricks via spark")
             scan.add_spark_session(spark, data_source_name=server.type)
             scan.set_data_source_name(server.type)
             spark.sql(f"USE {server.catalog}.{server.schema_}")
         else:
+            run.log_info("Connecting to databricks directly")
             soda_configuration_str = to_databricks_soda_configuration(server)
             scan.add_configuration_yaml_str(soda_configuration_str)
             scan.set_data_source_name(server.type)
@@ -183,4 +188,4 @@ def update_reason(check, c):
                 # print(check.reason)
             break  # Exit the loop once the desired block is found
     if "fail" in c["diagnostics"]:
-        check.reason = f"Got: {c['diagnostics']['value']} Expected: {c['diagnostics']['fail']}"
+        check.reason = f"Value: {c['diagnostics']['value']} Fail: {c['diagnostics']['fail']}"

datacontract/engines/soda/connections/databricks.py

@@ -4,15 +4,24 @@ import yaml
 
 
 def to_databricks_soda_configuration(server):
+    token = os.getenv("DATACONTRACT_DATABRICKS_TOKEN")
+    if token is None:
+        raise ValueError("DATACONTRACT_DATABRICKS_TOKEN environment variable is not set")
+    http_path = os.getenv("DATACONTRACT_DATABRICKS_HTTP_PATH")
+    host = server.host
+    if host is None:
+        host = os.getenv("DATACONTRACT_DATABRICKS_SERVER_HOSTNAME")
+    if host is None:
+        raise ValueError("DATACONTRACT_DATABRICKS_SERVER_HOSTNAME environment variable is not set")
     soda_configuration = {
         f"data_source {server.type}": {
             "type": "spark",
             "method": "databricks",
-            "host": server.host,
+            "host": host,
             "catalog": server.catalog,
             "schema": server.schema_,
-            "http_path": os.getenv("DATACONTRACT_DATABRICKS_HTTP_PATH"),
-            "token": os.getenv("DATACONTRACT_DATABRICKS_TOKEN"),
+            "http_path": http_path,
+            "token": token,
         }
     }
 

datacontract/export/dbml_converter.py

@@ -90,7 +90,7 @@ Note: {1}
 
 
 def generate_field(field_name: str, field: spec.Field, model_name: str, server: spec.Server) -> Tuple[str, str]:
-    if field.primary:
+    if field.primaryKey or field.primary:
         if field.required is not None:
             if not field.required:
                 raise DataContractException(
@@ -115,7 +115,7 @@ def generate_field(field_name: str, field: spec.Field, model_name: str, server:
             field.unique = True
 
     field_attrs = []
-    if field.primary:
+    if field.primaryKey or field.primary:
         field_attrs.append("pk")
 
     if field.unique:

datacontract/export/dbt_converter.py

@@ -39,13 +39,6 @@ def to_dbt_models_yaml(data_contract_spec: DataContractSpecification):
 
 
 def to_dbt_staging_sql(data_contract_spec: DataContractSpecification, model_name: str, model_value: Model) -> str:
-    if data_contract_spec.models is None or len(data_contract_spec.models.items()) != 1:
-        print(
-            "Export to dbt-staging-sql currently only works with exactly one model in the data contract."
-            "Please specify the model name."
-        )
-        return ""
-
     id = data_contract_spec.id
     columns = []
     for field_name, field in model_value.fields.items():
@@ -81,19 +74,21 @@ def to_dbt_sources_yaml(data_contract_spec: DataContractSpecification, server: s
 
     source["tables"] = []
     for model_key, model_value in data_contract_spec.models.items():
-        dbt_model = _to_dbt_source_table(model_key, model_value, adapter_type)
+        dbt_model = _to_dbt_source_table(data_contract_spec, model_key, model_value, adapter_type)
         source["tables"].append(dbt_model)
     return yaml.dump(dbt, indent=2, sort_keys=False, allow_unicode=True)
 
 
-def _to_dbt_source_table(model_key, model_value: Model, adapter_type: Optional[str]) -> dict:
+def _to_dbt_source_table(
+    data_contract_spec: DataContractSpecification, model_key, model_value: Model, adapter_type: Optional[str]
+) -> dict:
     dbt_model = {
         "name": model_key,
     }
 
     if model_value.description is not None:
         dbt_model["description"] = model_value.description
-    columns = _to_columns(model_value.fields, False, adapter_type)
+    columns = _to_columns(data_contract_spec, model_value.fields, False, adapter_type)
     if columns:
         dbt_model["columns"] = columns
     return dbt_model
@@ -114,7 +109,7 @@ def _to_dbt_model(model_key, model_value: Model, data_contract_spec: DataContrac
         dbt_model["config"]["contract"] = {"enforced": True}
     if model_value.description is not None:
         dbt_model["description"] = model_value.description
-    columns = _to_columns(model_value.fields, _supports_constraints(model_type), None)
+    columns = _to_columns(data_contract_spec, model_value.fields, _supports_constraints(model_type), None)
     if columns:
         dbt_model["columns"] = columns
     return dbt_model
@@ -137,15 +132,33 @@ def _supports_constraints(model_type):
     return model_type == "table" or model_type == "incremental"
 
 
-def _to_columns(fields: Dict[str, Field], supports_constraints: bool, adapter_type: Optional[str]) -> list:
+def _to_columns(
+    data_contract_spec: DataContractSpecification,
+    fields: Dict[str, Field],
+    supports_constraints: bool,
+    adapter_type: Optional[str],
+) -> list:
     columns = []
     for field_name, field in fields.items():
-        column = _to_column(field_name, field, supports_constraints, adapter_type)
+        column = _to_column(data_contract_spec, field_name, field, supports_constraints, adapter_type)
         columns.append(column)
     return columns
 
 
-def _to_column(field_name: str, field: Field, supports_constraints: bool, adapter_type: Optional[str]) -> dict:
+def get_table_name_and_column_name(references: str) -> tuple[Optional[str], str]:
+    parts = references.split(".")
+    if len(parts) < 2:
+        return None, parts[0]
+    return parts[-2], parts[-1]
+
+
+def _to_column(
+    data_contract_spec: DataContractSpecification,
+    field_name: str,
+    field: Field,
+    supports_constraints: bool,
+    adapter_type: Optional[str],
+) -> dict:
     column = {"name": field_name}
     adapter_type = adapter_type or "snowflake"
     dbt_type = convert_to_sql_type(field, adapter_type)
@@ -239,9 +252,21 @@ def _to_column(field_name: str, field: Field, supports_constraints: bool, adapte
                     }
                 }
             )
+    if field.references is not None:
+        ref_source_name = data_contract_spec.id
+        table_name, column_name = get_table_name_and_column_name(field.references)
+        if table_name is not None and column_name is not None:
+            column["data_tests"].append(
+                {
+                    "relationships": {
+                        "to": f"""source("{ref_source_name}", "{table_name}")""",
+                        "field": f"{column_name}",
+                    }
+                }
+            )
 
-        if not column["data_tests"]:
-            column.pop("data_tests")
+    if not column["data_tests"]:
+        column.pop("data_tests")
 
     # TODO: all constraints
     return column

datacontract/export/exporter.py

@@ -2,7 +2,10 @@ import typing
 from abc import ABC, abstractmethod
 from enum import Enum
 
-from datacontract.model.data_contract_specification import DataContractSpecification
+from datacontract.model.data_contract_specification import (
+    DataContractSpecification,
+    Model,
+)
 
 
 class Exporter(ABC):
@@ -40,6 +43,7 @@ class ExportFormat(str, Enum):
     sqlalchemy = "sqlalchemy"
     data_caterer = "data-caterer"
     dcs = "dcs"
+    markdown = "markdown"
     iceberg = "iceberg"
 
     @classmethod
@@ -49,7 +53,7 @@ class ExportFormat(str, Enum):
 
 def _check_models_for_export(
     data_contract: DataContractSpecification, model: str, export_format: str
-) -> typing.Tuple[str, str]:
+) -> typing.Tuple[str, Model]:
     if data_contract.models is None:
         raise RuntimeError(f"Export to {export_format} requires models in the data contract.")
 

datacontract/export/exporter_factory.py

@@ -48,7 +48,9 @@ def load_module_class(module_path, class_name):
 exporter_factory = ExporterFactory()
 
 exporter_factory.register_lazy_exporter(
-    name=ExportFormat.avro, module_path="datacontract.export.avro_converter", class_name="AvroExporter"
+    name=ExportFormat.avro,
+    module_path="datacontract.export.avro_converter",
+    class_name="AvroExporter",
 )
 
 exporter_factory.register_lazy_exporter(
@@ -70,15 +72,21 @@ exporter_factory.register_lazy_exporter(
 )
 
 exporter_factory.register_lazy_exporter(
-    name=ExportFormat.dbml, module_path="datacontract.export.dbml_converter", class_name="DbmlExporter"
+    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"
+    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"
+    name=ExportFormat.dbt,
+    module_path="datacontract.export.dbt_converter",
+    class_name="DbtExporter",
 )
 
 exporter_factory.register_lazy_exporter(
@@ -100,19 +108,27 @@ exporter_factory.register_lazy_exporter(
 )
 
 exporter_factory.register_lazy_exporter(
-    name=ExportFormat.odcs_v2, module_path="datacontract.export.odcs_v2_exporter", class_name="OdcsV2Exporter"
+    name=ExportFormat.odcs_v2,
+    module_path="datacontract.export.odcs_v2_exporter",
+    class_name="OdcsV2Exporter",
 )
 
 exporter_factory.register_lazy_exporter(
-    name=ExportFormat.odcs_v3, module_path="datacontract.export.odcs_v3_exporter", class_name="OdcsV3Exporter"
+    name=ExportFormat.odcs_v3,
+    module_path="datacontract.export.odcs_v3_exporter",
+    class_name="OdcsV3Exporter",
 )
 
 exporter_factory.register_lazy_exporter(
-    name=ExportFormat.odcs, module_path="datacontract.export.odcs_v3_exporter", class_name="OdcsV3Exporter"
+    name=ExportFormat.odcs,
+    module_path="datacontract.export.odcs_v3_exporter",
+    class_name="OdcsV3Exporter",
 )
 
 exporter_factory.register_lazy_exporter(
-    name=ExportFormat.go, module_path="datacontract.export.go_converter", class_name="GoExporter"
+    name=ExportFormat.go,
+    module_path="datacontract.export.go_converter",
+    class_name="GoExporter",
 )
 
 exporter_factory.register_lazy_exporter(
@@ -122,7 +138,9 @@ exporter_factory.register_lazy_exporter(
 )
 
 exporter_factory.register_lazy_exporter(
-    name=ExportFormat.html, module_path="datacontract.export.html_export", class_name="HtmlExporter"
+    name=ExportFormat.html,
+    module_path="datacontract.export.html_export",
+    class_name="HtmlExporter",
 )
 
 exporter_factory.register_lazy_exporter(
@@ -138,15 +156,21 @@ exporter_factory.register_lazy_exporter(
 )
 
 exporter_factory.register_lazy_exporter(
-    name=ExportFormat.sodacl, module_path="datacontract.export.sodacl_converter", class_name="SodaExporter"
+    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"
+    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"
+    name=ExportFormat.sql_query,
+    module_path="datacontract.export.sql_converter",
+    class_name="SqlQueryExporter",
 )
 
 exporter_factory.register_lazy_exporter(
@@ -156,7 +180,9 @@ exporter_factory.register_lazy_exporter(
 )
 
 exporter_factory.register_lazy_exporter(
-    name=ExportFormat.spark, module_path="datacontract.export.spark_converter", class_name="SparkExporter"
+    name=ExportFormat.spark,
+    module_path="datacontract.export.spark_converter",
+    class_name="SparkExporter",
 )
 
 exporter_factory.register_lazy_exporter(
@@ -166,7 +192,15 @@ exporter_factory.register_lazy_exporter(
 )
 
 exporter_factory.register_lazy_exporter(
-    name=ExportFormat.dcs, module_path="datacontract.export.dcs_exporter", class_name="DcsExporter"
+    name=ExportFormat.dcs,
+    module_path="datacontract.export.dcs_exporter",
+    class_name="DcsExporter",
+)
+
+exporter_factory.register_lazy_exporter(
+    name=ExportFormat.markdown,
+    module_path="datacontract.export.markdown_converter",
+    class_name="MarkdownExporter",
 )
 
 exporter_factory.register_lazy_exporter(

datacontract/export/iceberg_converter.py

@@ -105,14 +105,14 @@ def make_field(field_name, field):
     # Note 2: field_id defaults to 0 to signify that the exporter is not attempting to populate meaningful values.
     # also, the Iceberg sdk catalog code will re-set the fieldIDs prior to executing any table operations on the schema
     # ref: https://github.com/apache/iceberg-python/pull/1072
-    return types.NestedField(field_id=0, name=field_name, field_type=field_type, required=field.required)
+    return types.NestedField(field_id=0, name=field_name, field_type=field_type, required=field.required is True)
 
 
 def make_list(item):
     field_type = get_field_type(item)
 
     # element_id defaults to 0 to signify that the exporter is not attempting to populate meaningful values (see #make_field)
-    return types.ListType(element_id=0, element_type=field_type, element_required=item.required)
+    return types.ListType(element_id=0, element_type=field_type, element_required=item.required is True)
 
 
 def make_map(field):
@@ -121,7 +121,7 @@ def make_map(field):
 
     # key_id and value_id defaults to 0 to signify that the exporter is not attempting to populate meaningful values (see #make_field)
     return types.MapType(
-        key_id=0, key_type=key_type, value_id=0, value_type=value_type, value_required=field.values.required
+        key_id=0, key_type=key_type, value_id=0, value_type=value_type, value_required=field.values.required is True
     )