datacontract-cli 0.10.23__py3-none-any.whl → 0.10.37__py3-none-any.whl

datacontract_cli-0.10.37.dist-info/RECORD

@@ -0,0 +1,119 @@
+datacontract/__init__.py,sha256=ThDdxDJsd7qNErLoh628nK5M7RzhJNYCmN-C6BAJFoo,405
+datacontract/api.py,sha256=nFmrJOhC5AygY9YS1VXsbvKNtW92B8AF-lXdhuCvcPE,8578
+datacontract/cli.py,sha256=ix1iwdo8bGfUW_tf1qiSoLhGBKCLcIgpVgn6diV9MB0,20742
+datacontract/data_contract.py,sha256=24QE2ym5dfwTP6vJ0OmW37GNfGCCV6y4x4-J5Ouvfjk,13248
+datacontract/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datacontract/breaking/breaking.py,sha256=DnqgxUjD-EAZcg5RBizOP9a2WxsFTaQBik0AB_m3K00,20431
+datacontract/breaking/breaking_change.py,sha256=BIDEUo1U2CQLVT2-I5PyFttxAj6zQPI1UUkEoOOQXMY,2249
+datacontract/breaking/breaking_rules.py,sha256=M9IdzVJSA7oOr1fvLQl0y9MoBKeItPz42Db2U2cjH2Y,4063
+datacontract/catalog/catalog.py,sha256=U5TpDyT9kcF086DoDSS3bWBE4Q8uj6HVuCSFaxN5kMw,2830
+datacontract/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datacontract/engines/data_contract_checks.py,sha256=LNI0OZPrzrf7sn6lPgTL4uAHSqMH2VBrmaBo8etuSE0,37453
+datacontract/engines/data_contract_test.py,sha256=8qg0SkwtTmayfzNL2U_0xgx5Hi_DUePaMt2q_JiCqX8,4543
+datacontract/engines/datacontract/check_that_datacontract_contains_valid_servers_configuration.py,sha256=zrDn-_EJJ5kv0kZWAA-toeEPuBd3YQ0-U7Jb8euNUS8,1558
+datacontract/engines/datacontract/check_that_datacontract_file_exists.py,sha256=Vw-7U0GmQT2127tybxggZfpRFiZVgoIh6ndkTGM0FP4,665
+datacontract/engines/fastjsonschema/check_jsonschema.py,sha256=EKPkFM8iGyiWsHw8peErhQvbt9gu_zJ2S-NDQnupfeM,10921
+datacontract/engines/fastjsonschema/s3/s3_read_files.py,sha256=0sTDWvuu0AzSgn7fKWJxGaTmPww00TFYyDK-X0s5T3c,1193
+datacontract/engines/soda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datacontract/engines/soda/check_soda_execute.py,sha256=qc56ZNKyHIoSFgoXzBRioOhnhgsFSJ6L-nyBU7d0fW8,8902
+datacontract/engines/soda/connections/athena.py,sha256=wjrJA9CHhl6FbSW0HulWcYlkT2_nY1s19Y2MFe4lbCU,3028
+datacontract/engines/soda/connections/bigquery.py,sha256=C-8kxmzpYe88bJp80ObHFLMh4rpnIjnUQ7XOj0Ke7lk,903
+datacontract/engines/soda/connections/databricks.py,sha256=cMRasuO0MrSKVgHPB-9uFTGTZPFg6z9Kpk3tJ0SdR0s,943
+datacontract/engines/soda/connections/duckdb_connection.py,sha256=wGiB6EKr-OZosEFvT2gkutFgAzAxFMKicfpjbIJUZwQ,9332
+datacontract/engines/soda/connections/kafka.py,sha256=lnj_-3-CnJ6stetGqm6HOzN1Qatlw7xoCQU2zKBIXxU,8725
+datacontract/engines/soda/connections/postgres.py,sha256=9GTF4Es3M5vb7ocSGqAxXmslvkS5CjsPQGIuo020CFc,626
+datacontract/engines/soda/connections/snowflake.py,sha256=rfG2ysuqNM6TkvyqQKcGHFsTGJ6AROmud5VleUDRrb0,749
+datacontract/engines/soda/connections/sqlserver.py,sha256=RzGLbCUdRyfmDcqtM_AB9WZ-Xk-XYX91nkXpVNpYbvc,1440
+datacontract/engines/soda/connections/trino.py,sha256=JvKUP9aFg_n095oWE0-bGmfbETSWEOURGEZdQuG8txA,718
+datacontract/export/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datacontract/export/avro_converter.py,sha256=MnfeW2x-Eko9dK6_fpdQYWtEzLkFWXfKABAUSJqiDpo,5381
+datacontract/export/avro_idl_converter.py,sha256=SGO7JfI9UGXLYFR5wMGNUH1qf6kt9lF6dUU9roVqnFo,9878
+datacontract/export/bigquery_converter.py,sha256=9mm-XP3klu1C5J87L9EL5ZyMCJhLBwsixo3aAw9QmRI,4738
+datacontract/export/custom_converter.py,sha256=xb8KbkRRgHmT4ewwC7XxtnKpe_ZMSJWBjYOaKjmO_KQ,1216
+datacontract/export/data_caterer_converter.py,sha256=eSEuy3TbqUIG_lHYEBOydAgp_CJNoGArXrcJvh81wcw,5984
+datacontract/export/dbml_converter.py,sha256=f_OZEFwRUyL-Kg2yn_G58I8iz1VfFrZh8Nbw3Wq0JDo,4777
+datacontract/export/dbt_converter.py,sha256=58bub8n22dfL8w6bKdFe28BLF0e4PHbrxO_H3rZ9wfk,11840
+datacontract/export/dcs_exporter.py,sha256=RALQ7bLAjak7EsoFFL2GFX2Oju7pnCDPCdRN_wo9wHM,210
+datacontract/export/dqx_converter.py,sha256=5UevFPE8RdFIeu4CgeVnXMNDfWU7DhR34DW7O1aVIFs,4105
+datacontract/export/duckdb_type_converter.py,sha256=hUAAbImhJUMJOXEG-UoOKQqYGrJM6UILpn2YjUuAUOw,2216
+datacontract/export/excel_exporter.py,sha256=qDVcwO38aWPMTYyXo2qJd1HJLkmj_Izhi1hdVOQ8o_w,38424
+datacontract/export/exporter.py,sha256=DfvMHDWmdqhJswLkQ5oMNojgYDblXDuRgFJRHuFSawM,3085
+datacontract/export/exporter_factory.py,sha256=UvP3_U7xj-GEjaifi__Jri6eYKx9SFXtmSrnkSbWuP0,6318
+datacontract/export/go_converter.py,sha256=Ttvbfu3YU-3GBwRD6nwCsFyZuc_hiIvJD-Jg2sT5WLw,3331
+datacontract/export/great_expectations_converter.py,sha256=Wx0mESRy4xAf8y7HjESsGsQaaei8k9xOVu3RbC6BlQM,12257
+datacontract/export/html_exporter.py,sha256=EyTMj25_Df3irZiYw1hxVZeLYWp6YSG6z3IuFUviP14,3066
+datacontract/export/iceberg_converter.py,sha256=ArcQ_Y3z_W4_kGDU_8jPRx2-pHpP3Nhx1zYoETOL3c4,6804
+datacontract/export/jsonschema_converter.py,sha256=2MT82MurcQQbrVDRj1kFsxnmFd9scNSfYI1upQSecl4,5631
+datacontract/export/markdown_converter.py,sha256=J6QEGuopR9AUyEhux1GpjmJaQa1iihsbNMAmGRQ63BQ,10430
+datacontract/export/mermaid_exporter.py,sha256=Hg2yc5DYDTEZ7etoIhB1LU6rob_sGlouDtkPxUtf6kQ,4008
+datacontract/export/odcs_v3_exporter.py,sha256=b__AiPAnCUuFQE5DPHsvXBrMeEl1t_mJ1vzTx84TMlI,13931
+datacontract/export/pandas_type_converter.py,sha256=464pQ3JQKFQa1TO0HBNcEoZvQye_yUbY6jQtiBaphSc,1117
+datacontract/export/protobuf_converter.py,sha256=DHLl8BW26xqltBsd7Qhz0RhTl9YZQKCbkmjNpECgubg,7928
+datacontract/export/pydantic_converter.py,sha256=1Lt9F8i6zyQYb44MyQtsXwCWWXYxZ47SmzArr_uPqsU,5579
+datacontract/export/rdf_converter.py,sha256=zY2BZrRxM0J6C2cgf5zA8c7FxDRImFjZUrJ4ksmvSTw,6435
+datacontract/export/sodacl_converter.py,sha256=75vQ2TnoLfjiDtWT2x8opumvotXVRs1YaIu1NLYz05M,1473
+datacontract/export/spark_converter.py,sha256=aol9ygEq29mjrZNiaK3Vdm8kEZhCgFFphuFiFDX-pOE,7953
+datacontract/export/sql_converter.py,sha256=vyLbDqzt_J3LRXpPv2W2HqUIyAtQx_S-jviBiSxh14A,5087
+datacontract/export/sql_type_converter.py,sha256=eWHRHJNeg6oOT2uUPjmcVjEf6H_qXZvDhvSCk-_iBAM,13890
+datacontract/export/sqlalchemy_converter.py,sha256=0DMncvA811lTtd5q4ZORREQ9YH1vQm1lJeqMWsFvloE,6463
+datacontract/export/terraform_converter.py,sha256=ExFoEvErVk-gBnWJiqC38SxDUmUEydpACWc917l5RyM,2163
+datacontract/imports/avro_importer.py,sha256=isfAnMq9bk-Yo5zSyTnqMegu7JIujn_sTGSTOYAc8-0,11847
+datacontract/imports/bigquery_importer.py,sha256=7TcP9FDsIas5LwJZ-HrOPXZ-NuR056sxLfDDh3vjo8E,8419
+datacontract/imports/csv_importer.py,sha256=mBsmyTvfB8q64Z3NYqv4zTDUOvoXG896hZvp3oLt5YM,5330
+datacontract/imports/dbml_importer.py,sha256=o0IOgvXN34lU1FICDHm_QUTv0DKsgwbHPHUDxQhIapE,3872
+datacontract/imports/dbt_importer.py,sha256=hQwqD9vbvwLLc6Yj3tQbar5ldI0pV-ynSiz7CZZ0JCc,8290
+datacontract/imports/excel_importer.py,sha256=eBLc9VS9OYVFYFcHFHq9HYOStAPBDfVHwmgnBHjxOmc,46415
+datacontract/imports/glue_importer.py,sha256=fiJPkvfwOCsaKKCGW19-JM5CCGXZ2mkNrVtUzp2iw6g,8370
+datacontract/imports/iceberg_importer.py,sha256=vadGJVqQKgG-j8swUytZALFB8QjbGRqZPCcPcCy0vco,5923
+datacontract/imports/importer.py,sha256=NRhR_9AWPWDNq2ac_DVUHGoJuvkVpwwaao8nDfJG_l0,1257
+datacontract/imports/importer_factory.py,sha256=RS7uwkkT7rIKGeMKgPmZhE3GVC9IfZxZhm8XN0ooa3U,4124
+datacontract/imports/json_importer.py,sha256=JeGbqAC_wAO0u8HeMA5H-KJBfs6gpp1oGIpxt6nxSZI,12641
+datacontract/imports/jsonschema_importer.py,sha256=67H__XLugV4vguHrIqzW02dtx27zYTWnOms4D1ma3bk,4961
+datacontract/imports/odcs_importer.py,sha256=ZP2u3kJsgULANTbbqkP3joOlU9cUneZOPy6Ak3oTMgs,2140
+datacontract/imports/odcs_v3_importer.py,sha256=8mWFn4Ntf0jk0DKqmrp_DN7pKlSCO88Ol_UBWzHkY20,20467
+datacontract/imports/parquet_importer.py,sha256=W_0_16mX4stwDUt4GM2L7dnGmTpAySab5k13-OlTCCc,3095
+datacontract/imports/protobuf_importer.py,sha256=rlUIskv9PNi5rFQ4Hobt9zlnKpahGsb4dy5G5UJoVAw,10840
+datacontract/imports/spark_importer.py,sha256=OxX9hJhi8e1o1pZGOKh5zWsK96SX13r0WV04kKDD61M,8964
+datacontract/imports/sql_importer.py,sha256=AdbBe7RrOEDMwdDt4huF5XmOV2EDpOP-k_m8kFQRlJg,10130
+datacontract/imports/unity_importer.py,sha256=ZoWVMPffYNAXxPa0E8d6gRBtx3l-KSx0fPqnQx81DX0,9067
+datacontract/init/init_template.py,sha256=sLCxvXHqoeW-Qes9W8GSVPfDmmu7pfnVOm-puI1-wsQ,721
+datacontract/integration/datamesh_manager.py,sha256=FT9eadzFz181lg54b49_c_x2caGJT7mR3drlZBSBJLo,3375
+datacontract/lint/files.py,sha256=tg0vq_w4LQsEr_8A5qr4hUJmHeGalUpsXJXC1t-OGC0,471
+datacontract/lint/resolve.py,sha256=TjCS0wX4OIkQsV1fXpgGwfnDRyBLrFwePyLsEVO8Qs0,15339
+datacontract/lint/resources.py,sha256=nfeZmORh1aP7EKpMKCmfbS04Te8pQ0nz64vJVkHOq3c,647
+datacontract/lint/schema.py,sha256=wijp3Ix7WNqA2gnIQ6_IxbjB6fe35nYvMNM16dtAEA4,2220
+datacontract/lint/urls.py,sha256=giac0eAYa6hha8exleL3KsiPtiFlOq8l53axtAmCilw,2529
+datacontract/model/exceptions.py,sha256=5BMuEH2qWuckNP4FTfpUEeEu6rjgGcLOD0GQugKRQ1U,1242
+datacontract/model/odcs.py,sha256=Ku-n2xLC0_5EX7KxxLWrQ5ei5kugQiJy7AChKMmRWTc,782
+datacontract/model/run.py,sha256=4UdEUaJl5RxEpN9S3swSu1vGJUVyNhOpRkdfbBZhh90,3146
+datacontract/model/data_contract_specification/__init__.py,sha256=lO7ywraknlDwJNUaSd2B9FWFsWhE8v5S-kob_shW_lg,47
+datacontract/output/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datacontract/output/junit_test_results.py,sha256=ZjevRMTxNSiR0HMr3bEvqv4olozPw2zEutbuLloInww,4822
+datacontract/output/output_format.py,sha256=_ZokDBo7-HXBs6czUv7kLLf9cYft_q5QaKzthsVnc58,212
+datacontract/output/test_results_writer.py,sha256=PWNLs3R_LQMH4xp5WDxLkQgY3xvj8Eyzw1jnfgkQxlc,2713
+datacontract/schemas/datacontract-1.1.0.init.yaml,sha256=ij_-ZEJP4A7ekeJfoqGpRbiCys7_YjkClNluVVo4C6E,1828
+datacontract/schemas/datacontract-1.1.0.schema.json,sha256=3Bu2rxEjkF6dNLcqi1GF4KoXBnEIopaJ87Qb8S4zUvg,62872
+datacontract/schemas/datacontract-1.2.0.init.yaml,sha256=ij_-ZEJP4A7ekeJfoqGpRbiCys7_YjkClNluVVo4C6E,1828
+datacontract/schemas/datacontract-1.2.0.schema.json,sha256=sk7oL06cug9-WozCrLH8v8MuR3a8MaV1Ztkm1P-7UFk,64226
+datacontract/schemas/datacontract-1.2.1.init.yaml,sha256=ij_-ZEJP4A7ekeJfoqGpRbiCys7_YjkClNluVVo4C6E,1828
+datacontract/schemas/datacontract-1.2.1.schema.json,sha256=Ha6F8i2jaL3BKOV5kjWgaxzykAiaSLqjIq-OEOojnx4,65233
+datacontract/schemas/odcs-3.0.1.schema.json,sha256=bRZsSXA0fV0EmV_8f1K68PlXu1m4K7JcuHpLnY3ESwQ,72933
+datacontract/schemas/odcs-3.0.2.schema.json,sha256=_J13Tqc9E7RzpSho645meE86AxeU0dIt2U12-MnAfHk,69968
+datacontract/templates/datacontract.html,sha256=dksPEnY3c66jaaVS5r5vWfG6LzyXPjA4nO_yLUirJWg,17394
+datacontract/templates/datacontract_odcs.html,sha256=u4bpcgQVqwGmR0QjijJqecOClV2ZhpDvnNMAMzj4Ezc,32659
+datacontract/templates/index.html,sha256=EY2LYSTFCwMMcezsDbYsJwM5A7As7oOEiqTBpK_MXe8,12683
+datacontract/templates/partials/datacontract_information.html,sha256=7ZBxgEgi2XndKBypeOpe03oCSRPOujC6NVlN7zexGNM,6221
+datacontract/templates/partials/datacontract_servicelevels.html,sha256=ed3QgB11B0Qq2h_NwaroGZ4pQMBPEhfeQaoS-qEipqY,11401
+datacontract/templates/partials/datacontract_terms.html,sha256=1cnJcOTpxwot2BCuZmkLF_SPfiVloLs3c8mj9WfE4sc,1865
+datacontract/templates/partials/definition.html,sha256=gZEmNvwNGGxA_Fnzx_0L6tXlAMk_EAPWr5ziRIThb_o,1005
+datacontract/templates/partials/example.html,sha256=F1dWbHDIXQScgfs4OVgqM1lR4uV4xX5j6suasXHNM88,1204
+datacontract/templates/partials/model_field.html,sha256=2YBF95ypNCPFYuYKoeilRnDG-H_FuW4JK1znkCaYCac,7625
+datacontract/templates/partials/quality.html,sha256=ynEDWRn8I90Uje-xhGYgFcfwOgKI1R-CDki-EvTsauQ,1785
+datacontract/templates/partials/server.html,sha256=dHFJtonMjhiUHtT69RUgTpkoRwmNdTRzkCdH0LtGg_4,6279
+datacontract/templates/style/output.css,sha256=ioIo1f96VW7LHhDifj6QI8QbRChJl-LlQ59EwM8MEmA,28692
+datacontract_cli-0.10.37.dist-info/licenses/LICENSE,sha256=0hcS8X51AL0UvEsx1ZM6WQcxiy9d0j5iOfzdPYM6ONU,2205
+datacontract_cli-0.10.37.dist-info/METADATA,sha256=xG1Rilzh_eBYa-gBTG4b9AreKjV5-lcZ41sVqkHtHoc,115131
+datacontract_cli-0.10.37.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+datacontract_cli-0.10.37.dist-info/entry_points.txt,sha256=D3Eqy4q_Z6bHauGd4ppIyQglwbrm1AJnLau4Ppbw9Is,54
+datacontract_cli-0.10.37.dist-info/top_level.txt,sha256=VIRjd8EIUrBYWjEXJJjtdUgc0UAJdPZjmLiOR8BRBYM,13
+datacontract_cli-0.10.37.dist-info/RECORD,,

{datacontract_cli-0.10.23.dist-info → datacontract_cli-0.10.37.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{datacontract_cli-0.10.23.dist-info → datacontract_cli-0.10.37.dist-info/licenses}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 innoQ Deutschland GmbH
+Copyright (c) 2025 Entropy Data GmbH
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

datacontract/export/csv_type_converter.py

@@ -1,36 +0,0 @@
-# https://duckdb.org/docs/data/csv/overview.html
-# ['SQLNULL', 'BOOLEAN', 'BIGINT', 'DOUBLE', 'TIME', 'DATE', 'TIMESTAMP', 'VARCHAR']
-def convert_to_duckdb_csv_type(field) -> None | str:
-    type = field.type
-    if type is None:
-        return "VARCHAR"
-    if type.lower() in ["string", "varchar", "text"]:
-        return "VARCHAR"
-    if type.lower() in ["timestamp", "timestamp_tz"]:
-        return "TIMESTAMP"
-    if type.lower() in ["timestamp_ntz"]:
-        return "TIMESTAMP"
-    if type.lower() in ["date"]:
-        return "DATE"
-    if type.lower() in ["time"]:
-        return "TIME"
-    if type.lower() in ["number", "decimal", "numeric"]:
-        # precision and scale not supported by data contract
-        return "VARCHAR"
-    if type.lower() in ["float", "double"]:
-        return "DOUBLE"
-    if type.lower() in ["integer", "int", "long", "bigint"]:
-        return "BIGINT"
-    if type.lower() in ["boolean"]:
-        return "BOOLEAN"
-    if type.lower() in ["object", "record", "struct"]:
-        # not supported in CSV
-        return "VARCHAR"
-    if type.lower() in ["bytes"]:
-        # not supported in CSV
-        return "VARCHAR"
-    if type.lower() in ["array"]:
-        return "VARCHAR"
-    if type.lower() in ["null"]:
-        return "SQLNULL"
-    return "VARCHAR"

datacontract/lint/lint.py

@@ -1,142 +0,0 @@
-import abc
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any, Sequence, cast
-
-from datacontract.model.run import Check
-
-from ..model.data_contract_specification import DataContractSpecification
-
-"""This module contains linter definitions for linting a data contract.
-
-Lints are quality checks that can succeed, fail, or warn. They are
-distinct from checks such as "valid yaml" or "file not found", which
-will cause the processing of the data contract to stop. Lints can be
-ignored, and are high-level requirements on the format of a data
-contract."""
-
-
-class LintSeverity(Enum):
-    """The severity of a lint message. Generally, lint messages should be
-    emitted with a severity of ERROR. WARNING should be used when the linter
-    cannot determine a lint result, for example, when an unsupported model
-    type is used.
-    """
-
-    ERROR = 2
-    WARNING = 1
-
-
-@dataclass
-class LinterMessage:
-    """A single linter message with attached severity and optional "model" that
-    caused the message.
-
-    Attributes:
-       outcome: The outcome of the linting, either ERROR or WARNING. Linting outcomes with level WARNING are discarded for now.
-       message: A message describing the error or warning in more detail.
-       model: The model that caused the lint to fail. Is optional.
-
-    """
-
-    outcome: LintSeverity
-    message: str
-    model: Any = None
-
-    @classmethod
-    def error(cls, message: str, model=None):
-        return LinterMessage(LintSeverity.ERROR, message, model)
-
-    @classmethod
-    def warning(cls, message: str, model=None):
-        return LinterMessage(LintSeverity.WARNING, message, model)
-
-
-@dataclass
-class LinterResult:
-    """Result of linting a contract. Contains multiple LinterResults from
-       the same linter or lint phase.
-
-    Attributes:
-      linter: The linter that produced these results
-      results: A list of linting results. Multiple identical linting
-          results can be present in the list. An empty list means that
-          the linter ran without producing warnings or errors.
-    """
-
-    results: Sequence[LinterMessage] = field(default_factory=list)
-
-    @classmethod
-    def erroneous(cls, message, model=None):
-        return cls([LinterMessage.error(message, model)])
-
-    @classmethod
-    def cautious(cls, message, model=None):
-        return cls([LinterMessage.warning(message, model)])
-
-    def with_warning(self, message, model=None):
-        result = LinterMessage.warning(message, model)
-        return LinterResult(cast(list[LinterMessage], self.results) + [result])
-
-    def with_error(self, message, model=None):
-        result = LinterMessage.error(message, model)
-        return LinterResult(cast(list[LinterMessage], self.results) + [result])
-
-    def has_errors(self) -> bool:
-        return any(map(lambda result: result.outcome == LintSeverity.ERROR, self.results))
-
-    def has_warnings(self) -> bool:
-        return any(map(lambda result: result.outcome == LintSeverity.WARNING, self.results))
-
-    def error_results(self) -> Sequence[LinterMessage]:
-        return [result for result in self.results if result.outcome == LintSeverity.ERROR]
-
-    def warning_results(self) -> Sequence[LinterMessage]:
-        return [result for result in self.results if result.outcome == LintSeverity.WARNING]
-
-    def no_errors_or_warnings(self) -> bool:
-        return len(self.results) == 0
-
-    def combine(self, other: "LinterResult") -> "LinterResult":
-        return LinterResult(cast(list[Any], self.results) + cast(list[Any], other.results))
-
-
-class Linter(abc.ABC):
-    @property
-    @abc.abstractmethod
-    def name(self) -> str:
-        """Human-readable name of the linter."""
-        pass
-
-    @property
-    @abc.abstractmethod
-    def id(self) -> str:
-        """A linter ID for configuration (i.e. enabling and disabling)."""
-        pass
-
-    @abc.abstractmethod
-    def lint_implementation(self, contract: DataContractSpecification) -> LinterResult:
-        pass
-
-    def lint(self, contract: DataContractSpecification) -> list[Check]:
-        """Call with a data contract to get a list of check results from the linter."""
-        result = self.lint_implementation(contract)
-        checks = []
-        if not result.error_results():
-            checks.append(Check(type="lint", name=f"Linter '{self.name}'", result="passed", engine="datacontract"))
-        else:
-            # All linter messages are treated as warnings. Severity is
-            # currently ignored, but could be used in filtering in the future
-            # Linter messages with level WARNING are currently ignored, but might
-            # be logged or printed in the future.
-            for lint_error in result.error_results():
-                checks.append(
-                    Check(
-                        type="lint",
-                        name=f"Linter '{self.name}'",
-                        result="warning",
-                        engine="datacontract",
-                        reason=lint_error.message,
-                    )
-                )
-        return checks

datacontract/lint/linters/description_linter.py

@@ -1,35 +0,0 @@
-from datacontract.model.data_contract_specification import DataContractSpecification
-
-from ..lint import Linter, LinterResult
-
-
-class DescriptionLinter(Linter):
-    """Check for a description on contracts, models, model fields, definitions and examples."""
-
-    @property
-    def name(self) -> str:
-        return "Objects have descriptions"
-
-    @property
-    def id(self) -> str:
-        return "description"
-
-    def lint_implementation(self, contract: DataContractSpecification) -> LinterResult:
-        result = LinterResult()
-        if not contract.info or not contract.info.description:
-            result = result.with_error("Contract has empty description.")
-        for model_name, model in contract.models.items():
-            if not model.description:
-                result = result.with_error(f"Model '{model_name}' has empty description.")
-            for field_name, field in model.fields.items():
-                if not field.description:
-                    result = result.with_error(
-                        f"Field '{field_name}' in model '{model_name}'" f" has empty description."
-                    )
-        for definition_name, definition in contract.definitions.items():
-            if not definition.description:
-                result = result.with_error(f"Definition '{definition_name}' has empty description.")
-        for index, example in enumerate(contract.examples):
-            if not example.description:
-                result = result.with_error(f"Example {index + 1} has empty description.")
-        return result

datacontract/lint/linters/field_pattern_linter.py

@@ -1,34 +0,0 @@
-import re
-
-from datacontract.model.data_contract_specification import DataContractSpecification
-
-from ..lint import Linter, LinterResult
-
-
-class FieldPatternLinter(Linter):
-    """Checks that all patterns defined for fields are correct Python regex
-    syntax.
-
-    """
-
-    @property
-    def name(self):
-        return "Field pattern is correct regex"
-
-    @property
-    def id(self) -> str:
-        return "field-pattern"
-
-    def lint_implementation(self, contract: DataContractSpecification) -> LinterResult:
-        result = LinterResult()
-        for model_name, model in contract.models.items():
-            for field_name, field in model.fields.items():
-                if field.pattern:
-                    try:
-                        re.compile(field.pattern)
-                    except re.error as e:
-                        result = result.with_error(
-                            f"Failed to compile pattern regex '{field.pattern}' for "
-                            f"field '{field_name}' in model '{model_name}': {e.msg}"
-                        )
-        return result

datacontract/lint/linters/field_reference_linter.py

@@ -1,48 +0,0 @@
-from datacontract.model.data_contract_specification import DataContractSpecification
-
-from ..lint import Linter, LinterResult
-
-
-class FieldReferenceLinter(Linter):
-    """Checks that all references definitions in fields refer to existing
-    fields.
-
-    """
-
-    @property
-    def name(self):
-        return "Field references existing field"
-
-    @property
-    def id(self) -> str:
-        return "field-reference"
-
-    def lint_implementation(self, contract: DataContractSpecification) -> LinterResult:
-        result = LinterResult()
-        for model_name, model in contract.models.items():
-            for field_name, field in model.fields.items():
-                if field.references:
-                    reference_hierarchy = field.references.split(".")
-                    if len(reference_hierarchy) != 2:
-                        result = result.with_error(
-                            f"Field '{field_name}' in model '{model_name}'"
-                            f" references must follow the model.field syntax and refer to a field in a model in this data contract."
-                        )
-                        continue
-                    ref_model = reference_hierarchy[0]
-                    ref_field = reference_hierarchy[1]
-
-                    if ref_model not in contract.models:
-                        result = result.with_error(
-                            f"Field '{field_name}' in model '{model_name}'"
-                            f" references non-existing model '{ref_model}'."
-                        )
-                    else:
-                        ref_model_obj = contract.models[ref_model]
-                        if ref_field not in ref_model_obj.fields:
-                            result = result.with_error(
-                                f"Field '{field_name}' in model '{model_name}'"
-                                f" references non-existing field '{ref_field}'"
-                                f" in model '{ref_model}'."
-                            )
-        return result

datacontract/lint/linters/notice_period_linter.py

@@ -1,55 +0,0 @@
-import re
-
-from datacontract.model.data_contract_specification import DataContractSpecification
-
-from ..lint import Linter, LinterResult
-
-
-class NoticePeriodLinter(Linter):
-    @property
-    def name(self) -> str:
-        return "noticePeriod in ISO8601 format"
-
-    @property
-    def id(self) -> str:
-        return "notice-period"
-
-    # Regex matching the "simple" ISO8601 duration format
-    simple = re.compile(
-        r"""P             # Introduces period
-        (:?[0-9\.,]+Y)?   # Number of years
-        (:?[0-9\.,]+M)?   # Number of months
-        (:?[0-9\.,]+W)?   # Number of weeks
-        (:?[0-9\.,]+D)?   # Number of days
-        (:?               # Time part (optional)
-          T               # Always starts with T
-          (:?[0-9\.,]+H)? # Number of hours
-          (:?[0-9\.,]+M)? # Number of minutes
-          (:?[0-9\.,]+S)? # Number of seconds
-        )?
-        """,
-        re.VERBOSE,
-    )
-    datetime_basic = re.compile(r"P\d{8}T\d{6}")
-    datetime_extended = re.compile(r"P\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}")
-
-    def lint_implementation(self, contract: DataContractSpecification) -> LinterResult:
-        """Check whether the notice period is specified using ISO8601 duration syntax."""
-        if not contract.terms:
-            return LinterResult.cautious("No terms defined.")
-        period = contract.terms.noticePeriod
-        if not period:
-            return LinterResult.cautious("No notice period defined.")
-        if not period.startswith("P"):
-            return LinterResult.erroneous(f"Notice period '{period}' is not a valid" "ISO8601 duration.")
-        if period == "P":
-            return LinterResult.erroneous(
-                "Notice period 'P' is not a valid" "ISO8601 duration, requires at least one" "duration to be specified."
-            )
-        if (
-            not self.simple.fullmatch(period)
-            and not self.datetime_basic.fullmatch(period)
-            and not self.datetime_extended.fullmatch(period)
-        ):
-            return LinterResult.erroneous(f"Notice period '{period}' is not a valid ISO8601 duration.")
-        return LinterResult()

datacontract/lint/linters/quality_schema_linter.py

@@ -1,52 +0,0 @@
-import yaml
-
-from datacontract.model.data_contract_specification import DataContractSpecification, Model
-
-from ..lint import Linter, LinterResult
-
-
-class QualityUsesSchemaLinter(Linter):
-    @property
-    def name(self) -> str:
-        return "Quality check(s) use model"
-
-    @property
-    def id(self) -> str:
-        return "quality-schema"
-
-    def lint_sodacl(self, check, models: dict[str, Model]) -> LinterResult:
-        result = LinterResult()
-        for sodacl_check in check.keys():
-            table_name = sodacl_check[len("checks for ") :]
-            if table_name not in models:
-                result = result.with_error(f"Quality check on unknown model '{table_name}'")
-        return result
-
-    def lint_montecarlo(self, check, models: dict[str, Model]) -> LinterResult:
-        return LinterResult().with_warning("Linting montecarlo checks is not currently implemented")
-
-    def lint_great_expectations(self, check, models: dict[str, Model]) -> LinterResult:
-        return LinterResult().with_warning("Linting great expectations checks is not currently implemented")
-
-    def lint_implementation(self, contract: DataContractSpecification) -> LinterResult:
-        result = LinterResult()
-        models = contract.models
-        check = contract.quality
-        if not check:
-            return LinterResult()
-        if not check.specification:
-            return LinterResult.cautious("Quality check without specification.")
-        if isinstance(check.specification, str):
-            check_specification = yaml.safe_load(check.specification)
-        else:
-            check_specification = check.specification
-        match check.type:
-            case "SodaCL":
-                result = result.combine(self.lint_sodacl(check_specification, models))
-            case "montecarlo":
-                result = result.combine(self.lint_montecarlo(check_specification, models))
-            case "great-expectations":
-                result = result.combine(self.lint_great_expectations(check_specification, models))
-            case _:
-                result = result.with_warning("Can't lint quality check " f"with type '{check.type}'")
-        return result

datacontract/lint/linters/valid_constraints_linter.py

@@ -1,100 +0,0 @@
-from datacontract.model.data_contract_specification import DataContractSpecification, Field
-
-from ..lint import Linter, LinterResult
-
-
-class ValidFieldConstraintsLinter(Linter):
-    """Check validity of field constraints.
-
-    More precisely, check that only numeric constraints are specified on
-    fields of numeric type and string constraints on fields of string type.
-    Additionally, the linter checks that defined constraints make sense.
-    Minimum values should not be greater than maximum values, exclusive and
-    non-exclusive minimum and maximum should not be combined and string
-    pattern and format should not be combined.
-
-    """
-
-    valid_types_for_constraint = {
-        "pattern": set(["string", "text", "varchar"]),
-        "format": set(["string", "text", "varchar"]),
-        "minLength": set(["string", "text", "varchar"]),
-        "maxLength": set(["string", "text", "varchar"]),
-        "minimum": set(["int", "integer", "number", "decimal", "numeric", "long", "bigint", "float", "double"]),
-        "exclusiveMinimum": set(
-            ["int", "integer", "number", "decimal", "numeric", "long", "bigint", "float", "double"]
-        ),
-        "maximum": set(["int", "integer", "number", "decimal", "numeric", "long", "bigint", "float", "double"]),
-        "exclusiveMaximum": set(
-            ["int", "integer", "number", "decimal", "numeric", "long", "bigint", "float", "double"]
-        ),
-    }
-
-    def check_minimum_maximum(self, field: Field, field_name: str, model_name: str) -> LinterResult:
-        (min, max, xmin, xmax) = (field.minimum, field.maximum, field.exclusiveMinimum, field.exclusiveMaximum)
-        match (
-            "minimum" in field.model_fields_set,
-            "maximum" in field.model_fields_set,
-            "exclusiveMinimum" in field.model_fields_set,
-            "exclusiveMaximum" in field.model_fields_set,
-        ):
-            case (True, True, _, _) if min > max:
-                return LinterResult.erroneous(
-                    f"Minimum {min} is greater than maximum {max} on " f"field '{field_name}' in model '{model_name}'."
-                )
-            case (_, _, True, True) if xmin >= xmax:
-                return LinterResult.erroneous(
-                    f"Exclusive minimum {xmin} is greater than exclusive"
-                    f" maximum {xmax} on field '{field_name}' in model '{model_name}'."
-                )
-            case (True, True, True, True):
-                return LinterResult.erroneous(
-                    f"Both exclusive and non-exclusive minimum and maximum are "
-                    f"defined on field '{field_name}' in model '{model_name}'."
-                )
-            case (True, _, True, _):
-                return LinterResult.erroneous(
-                    f"Both exclusive and non-exclusive minimum are "
-                    f"defined on field '{field_name}' in model '{model_name}'."
-                )
-            case (_, True, _, True):
-                return LinterResult.erroneous(
-                    f"Both exclusive and non-exclusive maximum are "
-                    f"defined on field '{field_name}' in model '{model_name}'."
-                )
-        return LinterResult()
-
-    def check_string_constraints(self, field: Field, field_name: str, model_name: str) -> LinterResult:
-        result = LinterResult()
-        if field.minLength and field.maxLength and field.minLength > field.maxLength:
-            result = result.with_error(
-                f"Minimum length is greater that maximum length on" f" field '{field_name}' in model '{model_name}'."
-            )
-        if field.pattern and field.format:
-            result = result.with_error(
-                f"Both a pattern and a format are defined for field" f" '{field_name}' in model '{model_name}'."
-            )
-        return result
-
-    @property
-    def name(self):
-        return "Fields use valid constraints"
-
-    @property
-    def id(self):
-        return "field-constraints"
-
-    def lint_implementation(self, contract: DataContractSpecification) -> LinterResult:
-        result = LinterResult()
-        for model_name, model in contract.models.items():
-            for field_name, field in model.fields.items():
-                for _property, allowed_types in self.valid_types_for_constraint.items():
-                    if _property in field.model_fields_set and field.type not in allowed_types:
-                        result = result.with_error(
-                            f"Forbidden constraint '{_property}' defined on field "
-                            f"'{field_name}' in model '{model_name}'. Field type "
-                            f"is '{field.type}'."
-                        )
-                result = result.combine(self.check_minimum_maximum(field, field_name, model_name))
-                result = result.combine(self.check_string_constraints(field, field_name, model_name))
-        return result