sql-lineage-extractor 0.1.1__py3-none-any.whl

sql_lineage_extractor-0.1.1.dist-info/METADATA

@@ -0,0 +1,351 @@
+Metadata-Version: 2.4
+Name: sql-lineage-extractor
+Version: 0.1.1
+Summary: Static column-to-column SQL lineage extractor producing a dbt-manifest-like JSON graph.
+Author-email: Jeffrey YAPI <yapi.jeffrey@gmail.com>
+Maintainer-email: EasyTalents <yapi.jeffrey@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/easytalents/sql-lineage-extractor
+Project-URL: Repository, https://github.com/easytalents/sql-lineage-extractor
+Project-URL: Changelog, https://github.com/easytalents/sql-lineage-extractor/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/easytalents/sql-lineage-extractor/issues
+Keywords: sql,lineage,sqlglot,dbt,manifest,data-lineage,fabric
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: sqlglot<27,>=25
+Requires-Dist: click>=8.1
+Requires-Dist: jsonschema>=4.0
+Requires-Dist: tomli>=2.0; python_version < "3.11"
+Provides-Extra: live
+Requires-Dist: pyodbc>=5.0; extra == "live"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: mypy>=1.11; extra == "dev"
+Requires-Dist: types-jsonschema>=4.0; extra == "dev"
+Dynamic: license-file
+
+# sql-lineage-extractor
+
+[![CI](https://github.com/easytalents/sql-lineage-extractor/actions/workflows/ci.yml/badge.svg)](https://github.com/easytalents/sql-lineage-extractor/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/sql-lineage-extractor.svg)](https://pypi.org/project/sql-lineage-extractor/)
+[![Python](https://img.shields.io/pypi/pyversions/sql-lineage-extractor.svg)](https://pypi.org/project/sql-lineage-extractor/)
+[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
+
+Extraction **statique** de lineage SQL **colonne-à-colonne**, inspirée du
+`manifest.json` de dbt — mais **sans moteur d'exécution ni orchestration**.
+L'outil n'exécute aucune requête de transformation, ne charge aucune donnée : il
+analyse du **texte SQL** et produit un **graphe structuré** (JSON versionné et
+diffable).
+
+Le SQL analysé peut provenir indifféremment de :
+
+- fichiers `.sql` ;
+- notebooks Fabric / Jupyter (`.ipynb`) ;
+- une connexion **live** à un endpoint SQL (Fabric SQL endpoint, SQL Server,
+  Synapse) via une connexion DB-API générique **injectée de l'extérieur**.
+
+Aucune dépendance à un SDK Fabric propriétaire. Le parsing repose sur
+[`sqlglot`](https://github.com/tobymao/sqlglot).
+
+## Installation
+
+```bash
+pip install -e .
+# mode live (connexion DB-API, ex. pyodbc) :
+pip install -e ".[live]"
+# outillage de dev (tests) :
+pip install -e ".[dev]"
+```
+
+Python ≥ 3.10.
+
+## Architecture — pipeline en 4 couches
+
+```
+Sources SQL (fichiers / notebooks / live)
+        │  -> SQLUnit (id, dialecte, sql_text, origine)
+        ▼
+Parsing + lineage colonne-à-colonne (sqlglot)   -> ObjectNode | ParseError
+        ▼
+Construction du graphe multi-objets (depends_on_nodes)
+        ▼
+Sérialisation en manifest JSON (schématisé, déterministe)
+```
+
+Chaque couche est testable indépendamment (`tests/`).
+
+## Utilisation (CLI)
+
+```bash
+# Fichiers .sql
+sql-lineage extract --source files     --path ./vues       --dialect tsql  --out manifest.json
+
+# Notebooks .ipynb
+sql-lineage extract --source notebooks --path ./notebooks  --dialect spark --out manifest.json
+
+# Endpoint SQL live (nécessite l'extra [live])
+sql-lineage extract --source live      --conn-string "<DSN ou chaîne ODBC>" --dialect tsql --out manifest.json
+
+# Vérifier qu'un manifest est conforme au schéma publié
+sql-lineage validate manifest.json
+```
+
+Options utiles : `--glob` pour restreindre le motif de fichiers
+(`--glob "silver/**/*.sql"`).
+
+### Utilisation programmatique
+
+```python
+from sql_lineage.sources import FileSQLSource
+from sql_lineage.pipeline import run_extraction
+from sql_lineage.manifest import write_manifest
+
+nodes, errors = run_extraction(FileSQLSource("./vues", dialect="tsql"))
+write_manifest("manifest.json", nodes, errors)
+```
+
+Pour le mode live, la connexion est **fournie par l'appelant** (jamais construite
+dans la librairie) :
+
+```python
+import pyodbc
+from sql_lineage.sources import LiveSQLEndpointSource
+
+conn = pyodbc.connect("Driver=...;Server=...;Authentication=ActiveDirectoryInteractive;...")
+source = LiveSQLEndpointSource(conn, dialect="tsql")
+```
+
+## Schéma du manifest
+
+Documenté et versionné dans
+[`src/sql_lineage/manifest/schema.json`](src/sql_lineage/manifest/schema.json)
+(`schema_version` en tête de fichier, actuellement `1.0`). La **politique
+d'évolution** du contrat (MAJOR.MINOR, dépréciation, golden tests) est décrite
+dans [docs/MANIFEST_SCHEMA.md](docs/MANIFEST_SCHEMA.md). Extrait :
+
+```json
+{
+  "schema_version": "1.0",
+  "generated_at": "2026-07-20T10:00:00Z",
+  "nodes": {
+    "silver_shipping_escale": {
+      "origine": "vues-shipping/silver/escale.sql",
+      "dialecte": "tsql",
+      "columns": {
+        "date_traitement": {
+          "expression_sql": "e.date_arrivee AS date_traitement",
+          "depends_on": [{"table": "bronze_navis.escale", "column": "date_arrivee"}]
+        }
+      },
+      "depends_on_nodes": ["bronze_navis_escale"],
+      "parametres_neutralises": [],
+      "avertissements": []
+    }
+  },
+  "errors": [
+    {"id": "silver_finance_xyz", "origine": "...", "message": "..."}
+  ]
+}
+```
+
+**Déterminisme** : même entrée → même sortie. Clés triées, listes ordonnées,
+formatage stable — pour un diff propre en CI. Le seul champ non reproductible,
+`generated_at`, est injectable (`build_manifest(..., generated_at=...)`).
+
+## Export vers la BI (Power BI, etc.)
+
+Le manifest JSON reste **canonique** (contrat versionné, diffable en CI). Pour la
+BI on en **dérive** une couche de service tabulaire — schéma en étoile — que
+Power BI consomme directement, sans avoir à « expand » du JSON imbriqué :
+
+```
+manifest.json  (canonique)
+      │  sql-lineage export  (dérivation pure, rejouable, append par run)
+      ▼
+dim_run · dim_object · dim_column · fact_column_edge · object_edge · closure · errors
+```
+
+| Table | Grain | Rôle |
+|---|---|---|
+| `dim_run` | 1 run | dimension temps (historisation) |
+| `dim_object` | 1 objet | dimension (slice par `layer` bronze/silver/gold) |
+| `dim_column` | 1 colonne | dimension colonne |
+| `fact_column_edge` | 1 arête colonne→colonne | **fait central** |
+| `object_edge` | 1 dépendance objet directe | graphe 1-saut |
+| `closure` | 1 couple ancêtre→descendant | **multi-saut** (impact / provenance) |
+| `errors` | 1 erreur | suivi qualité |
+
+Toutes les tables portent un `run_id` : chaque run est **ajouté** (jamais
+écrasé), ce qui ouvre la dérive dans le temps, l'« as-of date » et l'audit. La
+table `closure` (fermeture transitive précalculée en Python) débloque les
+rapports *impact* (« si cette source change, quoi en aval ? ») et *provenance*
+(« d'où vient cette colonne à la source ? ») sur plusieurs niveaux — impossible
+en DAX récursif sur un DAG.
+
+### Backends
+
+```bash
+# CSV (un fichier par table)
+sql-lineage export manifest.json --format csv       --out ./exports
+
+# SQLite (fichier unique, lisible par Power BI via ODBC)
+sql-lineage export manifest.json --format sqlite    --out lineage.db
+
+# SQL Server / Fabric Warehouse (connexion injectée)
+sql-lineage export manifest.json --format sqlserver --conn-string "<chaîne ODBC>"
+```
+
+Le backend `sqlserver` utilise l'extra `[live]` (pyodbc). Les backends base de
+données sont **idempotents par run** (les lignes d'un `run_id` existant sont
+remplacées) ; le CSV est append-only.
+
+> **Fabric** : guide d'usage complet (exécution hors Spark, connexion Warehouse
+> via Service Principal, script d'orchestration prêt à coller) dans
+> [docs/FABRIC_USAGE.md](docs/FABRIC_USAGE.md) et
+> [examples/fabric_orchestration.py](examples/fabric_orchestration.py).
+
+### Modélisation Power BI (indicatif)
+
+- Relations : `dim_object[node_id] 1—* fact_column_edge[target_node]` ;
+  `dim_run[run_id] 1—*` sur chaque table (filtre de run).
+- Impact/provenance : filtrer `closure[ancestor_node]` (aval) ou
+  `closure[descendant_node]` (amont), `depth` donne la distance.
+- Volume faible → **mode Import** suffit (pas besoin de DirectQuery/DirectLake).
+
+## Conventions
+
+### Identifiant d'un objet dans un notebook
+
+Priorité de résolution de l'`id` d'une cellule / d'un appel `spark.sql` :
+
+1. **Commentaire de convention** en tête du SQL :
+   `-- lineage:id=silver_shipping_escale` *(valeur par défaut, ajustable si
+   l'équipe data préfère une autre convention)*.
+2. **Nom de la variable cible** en Python (`df_silver_finance = spark.sql(...)`
+   → `silver_finance` ; le préfixe `df_` est retiré).
+3. **Repli** `nom_notebook#numero_cellule` — ce cas émet un **avertissement**
+   (champ `avertissements`), il n'est jamais silencieux.
+
+### Neutralisation des f-strings
+
+Une cellule Python `spark.sql(f"... WHERE d >= '{date_execution}'")` est parsée
+avec le module `ast` (jamais par regex). Chaque interpolation `{...}` **en
+position valeur** (`>= {x}`, `'{x}'`, `IN ({x})`) est remplacée par le jeton
+neutre `__PARAM__` avant transmission à sqlglot, pour ne pas casser le parsing.
+
+Une interpolation qui occupe **une ligne à elle seule** est traitée comme un
+**fragment de clause SQL** (motif courant en Fabric :
+`{'' if terminal_names is None else 'AND t.col IN ' + terminal_names}`) et
+**supprimée** plutôt que tokenisée — un `__PARAM__` orphelin casserait le parsing,
+et un prédicat `WHERE`/`HAVING` ne contribue jamais au lineage colonne.
+
+Dans les deux cas, les fragments remplacés/supprimés sont conservés dans le champ
+`parametres_neutralises` du nœud, pour transparence.
+
+### Personnaliser les conventions (`LineageConfig`)
+
+**Aucune convention n'est codée en dur** : le commentaire d'id, le préfixe de
+variable, le jeton de neutralisation et le dialecte par défaut proviennent tous
+d'un objet `LineageConfig` **injectable**. Les défauts reproduisent exactement le
+comportement décrit ci-dessus (rétro-compatible).
+
+```python
+from sql_lineage import LineageConfig
+from sql_lineage.sources import NotebookSQLSource
+
+config = LineageConfig(
+    id_comment_pattern=r"--\s*lin:id\s*=\s*(\w+)",  # 1 groupe de capture = l'id
+    var_prefixes=("df_", "result_"),                 # préfixes retirés de l'id
+    param_token="@@PARAM@@",
+    default_dialect="spark",
+)
+source = NotebookSQLSource("./notebooks", config=config)
+```
+
+La même chose en CLI (les flags surchargent un éventuel `--config`) :
+
+```bash
+sql-lineage extract --source notebooks --path ./notebooks \
+    --config conventions.toml \
+    --var-prefix df_ --var-prefix result_ \
+    --id-comment-pattern '--\s*lin:id\s*=\s*(\w+)' \
+    --param-token '@@PARAM@@' \
+    --out manifest.json
+```
+
+Fichier de conventions (`.toml` ou `.json`) — les clés peuvent aussi vivre sous
+`[tool.sql_lineage]` d'un `pyproject.toml` partagé :
+
+```toml
+[sql_lineage]
+var_prefixes = ["df_", "result_"]
+param_token = "@@PARAM@@"
+default_dialect = "spark"
+```
+
+La convention `-- lineage:id=` s'applique aussi aux **fichiers `.sql`** : un
+commentaire présent dans le fichier l'emporte sur l'id dérivé du nom de fichier.
+
+## Cas d'erreur (attendus)
+
+Une erreur de parsing sur **un** objet n'interrompt **jamais** le traitement des
+autres : elle est capturée et reportée dans `errors`. Cas rejetés :
+
+- `SELECT *` (et `t.*`) **sur une table physique** : colonnes inconnues en
+  analyse statique. En revanche, un `SELECT *` **au-dessus d'un CTE ou d'une
+  sous-requête énumérable est expansé automatiquement** (y compris les cas
+  imbriqués `T.*`), donc supporté.
+- Colonne calculée **sans alias** (`e.a + e.b`) : pas de nom de sortie stable.
+- SQL non analysable par sqlglot pour le dialecte donné.
+
+## Limites connues
+
+- **SQL procédural complexe** (batchs T-SQL multi-instructions, variables,
+  `MERGE`, procédures stockées) : seul le premier `SELECT` pertinent est analysé.
+- **Dialectes** : testés sur `tsql` et `spark`. Les autres dialectes sqlglot
+  fonctionnent probablement mais ne sont pas couverts par les tests — à étendre
+  selon les besoins.
+- **Résolution du graphe** : le rapprochement `table source ↔ objet` normalise
+  les points en underscores (`bronze_navis.escale` ↔ `bronze_navis_escale`) et
+  autorise un match sur le dernier segment. Des collisions de noms courts sont
+  théoriquement possibles.
+- **Non-objectifs** : pas d'exécution de requêtes, pas de génération de site de
+  documentation (le manifest est destiné à être consommé par un outil de rendu
+  séparé), pas de tests de qualité de données.
+
+## Tests
+
+```bash
+pytest
+```
+
+Aucun test ne nécessite de connexion réseau ni d'accès à un environnement Fabric
+réel — le mode live est couvert par une connexion **mockée**.
+
+## Structure du dépôt
+
+```
+src/sql_lineage/
+  models.py              # SQLUnit, ColumnLineage, ObjectNode, ParseError, ColumnSource
+  sources/               # file / notebook / live  (interface commune SQLSource)
+  parsing/               # wrapper sqlglot + extraction de lineage
+  graph/                 # construction des arêtes depends_on_nodes
+  manifest/              # schema.json + writer (sérialisation déterministe)
+  pipeline.py            # orchestration source -> parse -> graph
+  cli.py                 # commandes `extract` / `validate` (click)
+tests/                   # fixtures .sql / .ipynb + tests par couche
+```

sql_lineage_extractor-0.1.1.dist-info/RECORD

@@ -0,0 +1,30 @@
+sql_lineage/__init__.py,sha256=xDTjWvcTGOcDql_19uQIzCk_B5sMbuJFS5R93_eHhNw,726
+sql_lineage/_version.py,sha256=mEr1FdwwZVMovyM6vpPg2W8zwa1u1f4KdymTrLcqf9U,520
+sql_lineage/cli.py,sha256=6zrThjZPUD5jplehT5qxFHMD4AL6Ku_rObu5PTQazrM,7530
+sql_lineage/config.py,sha256=at-A75g8jjfoL6OHA0F9zsbcCfBGOcxOvq8xrCMi8Yg,5980
+sql_lineage/models.py,sha256=ouvweFKdLdqE-VI7WERvQ6A_K1VJGwzYTfNJnvixWUg,2221
+sql_lineage/pipeline.py,sha256=Q9cbGT-x-bAxVq2wqPXGwui0p-7-0PUhafCFwpfCHmk,871
+sql_lineage/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sql_lineage/export/__init__.py,sha256=6bf5YXYli7iB9aDM-MUnHXG0kWXXgCBJoJP_evepoY0,1093
+sql_lineage/export/backends.py,sha256=rLzGWpPXP-JEowgdAIGX_oteqK-w30bylAeeJlhFfK4,4450
+sql_lineage/export/tables.py,sha256=MQC_jy6ZIZfgE9IvLIVQh4ULzGAvLwmbwG8T3wzaRXw,6426
+sql_lineage/graph/__init__.py,sha256=gVav6n39_ddTcdfu3nLD_zFmzGq8Cf05eU5eS7TAEgI,60
+sql_lineage/graph/builder.py,sha256=UA-mvciJiMxNmUF3Ifu_QpBDsCvECVl0V6FXxK3oqNg,1686
+sql_lineage/manifest/__init__.py,sha256=jyeN-inwuQ1kb4cZq0wVTz7yb-lfFLsyABx65mZpwdc,291
+sql_lineage/manifest/schema.json,sha256=9HJ56_X2lH1aBqCIGmWeyvu0WeboKHn5yaD7kRg2hzU,2489
+sql_lineage/manifest/writer.py,sha256=AU2tjEICQpZ81CfIKpCnxa2IDUasnfJlkIBAtTJ7KuI,2834
+sql_lineage/parsing/__init__.py,sha256=8QsXUNKoi87xX4Jn-k8fkWId5XU25gjAI2h358SRAgQ,137
+sql_lineage/parsing/engine.py,sha256=k1WBnMeN_cOL63o8JHNdVgI9-JQdlulDYShKTnN_5AU,6131
+sql_lineage/parsing/lineage_extractor.py,sha256=IRuC3OjNSZSBKsiRaK__2DRiLu38hmFCTAAERHsBbpM,1590
+sql_lineage/sources/__init__.py,sha256=QEpFqk8miRMBzL2n8JAL4toxj7MOUmdJiISWZaHlFHU,328
+sql_lineage/sources/base.py,sha256=jNs7Xj4k1sbYNQ_oSltfFIZ9fkh4HJkbcSjp6nVlp8c,366
+sql_lineage/sources/file_source.py,sha256=SSJQhwfvSp3JqjWdd7pvr9fCNm6FMDQaUbSC1r3P2cg,1790
+sql_lineage/sources/live_sql_source.py,sha256=n71Keq6Kg3wk5l8Pb1ezpG_Ru4sC2GCURnYz-ZgDrqA,2772
+sql_lineage/sources/notebook_source.py,sha256=DIy-6_-CDW3-7A3hXakdEMTQMcnmjpvSKVxdcktapTk,9326
+sql_lineage_extractor-0.1.1.dist-info/licenses/LICENSE,sha256=P-Id9eVer3mJbTOjtqe6vmxDOt2NK_g496EAt-K-FSs,11341
+sql_lineage_extractor-0.1.1.dist-info/licenses/NOTICE,sha256=uLxA8KJ_ssC-ZUVMG_kj_QDVsef-ZDRgMWnGS9On7B4,406
+sql_lineage_extractor-0.1.1.dist-info/METADATA,sha256=nWlUwmNZlPywPsaJCUihNImEQxP5cvhSHSj9nBJpjVs,14004
+sql_lineage_extractor-0.1.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+sql_lineage_extractor-0.1.1.dist-info/entry_points.txt,sha256=eoCALC2HSZ0tas2oi71X1rZJXt_NecOYimeaci7LrVA,52
+sql_lineage_extractor-0.1.1.dist-info/top_level.txt,sha256=JP0H16J5QkUF4V8Z-hMMPMlWm58sXGq0w6y92PJeQ00,12
+sql_lineage_extractor-0.1.1.dist-info/RECORD,,

sql_lineage_extractor-0.1.1.dist-info/WHEEL

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

sql_lineage_extractor-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sql-lineage = sql_lineage.cli:cli

sql_lineage_extractor-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and do
+          not modify the License. You may add Your own attribution notices
+          within Derivative Works that You distribute, alongside or as an
+          addendum to the NOTICE text from the Work, provided that such
+          additional attribution notices cannot be construed as modifying
+          the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 EasyTalents
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

sql_lineage_extractor-0.1.1.dist-info/licenses/NOTICE

@@ -0,0 +1,13 @@
+sql-lineage-extractor
+Copyright 2026 EasyTalents
+
+This product was developed by EasyTalents.
+Author: Jeffrey YAPI
+
+Licensed under the Apache License, Version 2.0 (see the LICENSE file).
+
+This product depends on third-party software distributed under their own
+licenses, notably:
+  - sqlglot (MIT License) — https://github.com/tobymao/sqlglot
+  - click (BSD-3-Clause License)
+  - jsonschema (MIT License)

sql_lineage_extractor-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+sql_lineage