cvgruplac-json 0.1.0__tar.gz

cvgruplac_json-0.1.0/.gitignore

@@ -0,0 +1,17 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.venv/
+venv/
+.pytest_cache/
+.ruff_cache/
+.coverage
+coverage.xml
+htmlcov/
+# Add here any generated outputs or data files that hold personal data (e.g. downloaded pages)
+# Never commit credentials
+.env
+.pypirc
+*apikey*

cvgruplac_json-0.1.0/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and versions follow [Semantic Versioning](https://semver.org/).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-11-15
+
+### Added
+- First version: `cvgruplac-json --cvlac … --gruplac … --out …` and `link`, `link_gruplac`, `link_cvlac`, `id_hash`.
+  Every product of a GrupLAC (gruplac-json) and of a CvLAC (cvlac-json) gets `id` and `scrapping_ids`
+  (`{id, source}`; `verified: false` on cvlac ids that could not be checked; `group` on gruplac ids in a CvLAC).
+  GrupLAC products copy the first verified member CvLAC id; the others, and CvLAC events, get `id_hash`, the
+  product_hash recipe with the group code or the COD_RH and the extra kind `event`. Section pairing of CvLAC and
+  GrupLAC in `data/sections.json`. Gzipped outputs are written at level 6.
+
+[Unreleased]: https://github.com/restrepo/cvgruplac-json/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/restrepo/cvgruplac-json/releases/tag/v0.1.0

cvgruplac_json-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Diego Restrepo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cvgruplac_json-0.1.0/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.5
+Name: cvgruplac-json
+Version: 0.1.0
+Summary: Link the JSONs of cvlac-json and gruplac-json: one id per product, in both directions.
+Project-URL: Homepage, https://github.com/restrepo/cvgruplac-json
+Project-URL: Repository, https://github.com/restrepo/cvgruplac-json
+Project-URL: Issues, https://github.com/restrepo/cvgruplac-json/issues
+Project-URL: Changelog, https://github.com/restrepo/cvgruplac-json/blob/main/CHANGELOG.md
+Author-email: Diego Restrepo <restrepo@udea.edu.co>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest-cov>=5; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff==0.17.3; extra == 'dev'
+Requires-Dist: twine>=5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# cvgruplac-json
+
+[![CI](https://github.com/restrepo/cvgruplac-json/actions/workflows/ci.yml/badge.svg)](https://github.com/restrepo/cvgruplac-json/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/cvgruplac-json.svg)](https://pypi.org/project/cvgruplac-json/)
+[![Python](https://img.shields.io/pypi/pyversions/cvgruplac-json.svg)](https://pypi.org/project/cvgruplac-json/)
+
+Une los JSON de [cvlac-json](https://github.com/restrepo/cvlac-json) (el CvLAC de una persona) y de
+[gruplac-json](https://github.com/restrepo/gruplac-json) (el GrupLAC de un grupo) de Minciencias: cada producto de
+los dos recibe un `id` y una lista `scrapping_ids` con sus ids en una y otra fuente, así que un producto del grupo
+apunta al mismo producto en el CV de cada integrante que lo firmó, y al revés.
+
+No descarga nada ni llama a ninguna API: lee los JSON que ya escribieron los dos paquetes y escribe copias unidas,
+sin tocar los originales. Solo usa la biblioteca estándar.
+
+## Instalación
+
+```bash
+pip install cvgruplac-json
+```
+
+## Uso
+
+```bash
+cvgruplac-json --cvlac cvlac/ --gruplac gruplac/ --out unidos/
+cvgruplac-json --cvlac cvlac_udea/ cvlac_colombia/json/ --gruplac gruplac/json/ --out unidos/ --workers 4
+cvgruplac-json --gruplac gruplac_COL0008423.json --cvlac cvlac_0000707619.json --out unidos/
+cvgruplac-json --gruplac gruplac/ --out unidos/        # sin CvLAC: ids de CvLAC sin verificar
+```
+
+- `--cvlac` y `--gruplac` reciben archivos o carpetas (`cvlac_*.json[.gz]`, `gruplac_*.json[.gz]`). Si un COD_RH o
+  un grupo está en más de una entrada, gana la primera.
+- Escribe `unidos/gruplac/` y `unidos/cvlac/` con el mismo nombre y compresión de cada entrada, y
+  `unidos/cvgruplac_summary.json` con los conteos y los archivos que no pudo leer. `--only gruplac` escribe solo los
+  GrupLAC.
+- Hace tres pasadas: lee los hashes de los CvLAC, une los GrupLAC y luego los CvLAC.
+
+En Python:
+
+```python
+from cvgruplac_json import link, link_gruplac, link_cvlac, id_hash
+
+index = link(gruplacs, cvlacs)  # listas de dicts de gruplac-json y cvlac-json, unidos en su lugar
+```
+
+## Los identificadores
+
+Cada producto (obras, proyectos, eventos, patentes y cada ítem de `other_products`) empieza con dos claves:
+
+```json
+"id": "efc8d0bb2fa50a617767aa814a57a7a40c1c956f",
+"scrapping_ids": [
+  {"id": "efc8d0bb2fa50a617767aa814a57a7a40c1c956f", "source": "cvlac"},
+  {"id": "efc8d0bb2fa50a617767aa814a57a7a40c1c956f", "source": "gruplac"}
+]
+```
+
+**En un GrupLAC**
+
+- `source: "cvlac"`: una por integrante autor con `product_hash`, en el orden de los autores. Es el id del producto
+  en el CvLAC de ese integrante (el `product_hash` que cvlac-json pone en la entrada del dueño). Si el CvLAC del
+  integrante está entre las entradas, se pone solo si el producto está en él; si no está, se pone con
+  `"verified": false`. No hay ninguna en las secciones que solo tiene el GrupLAC
+  ([`data/sections.json`](src/cvgruplac_json/data/sections.json)), ni en proyectos y eventos, que el GrupLAC lista
+  sin autores.
+- `source: "gruplac"`, siempre la última: el primer id de CvLAC si lo hay, así que un producto que está en los dos
+  tiene el mismo id. Si no, el SHA-1 de `título|código COL|tipo|año` (abajo).
+- `id` es el de `source: "gruplac"`.
+
+**En un CvLAC**
+
+- `source: "cvlac"`: el `product_hash` del dueño. Los productos sin él (los eventos) usan el SHA-1 de
+  `título|COD_RH|event|año`.
+- `source: "gruplac"`, con `group` (código COL): una por cada producto de un GrupLAC que lo lista como id de CvLAC
+  verificado. Un artículo del CV que está en dos grupos tiene dos.
+- `id` es el de `source: "cvlac"` y reemplaza el `id` por posición de cvlac-json (`cvlac:COD_RH:n`).
+
+**El hash.** `id_hash(título, dueño, tipo, año, n)` es la receta del `product_hash` con el dueño que corresponda: el
+SHA-1 de
+
+```
+<título>|<dueño>|<tipo>|<año>
+```
+
+- título en minúsculas, sin tildes y solo con letras y dígitos; un ítem sin título usa su nombre (eventos) o su texto;
+- dueño: el código COL del grupo (el número GrupLAC de 14 dígitos si no tiene), o el COD_RH con 10 dígitos (con un
+  COD_RH y los tipos `work`, `project`, `patent` y `other` da exactamente el `product_hash`);
+- tipo: `work`, `project`, `event`, `patent` u `other`;
+- año: `year_published`, `year`, el año de `start` o el de `date`.
+
+Si varios productos del mismo JSON dan la misma clave, el n-ésimo, en el orden de la página, lleva `|n` al final; y
+un candidato ya usado en ese JSON pasa al siguiente `n`. Por eso `id` es único dentro de cada GrupLAC y de cada
+CvLAC. Ejemplo de clave de un evento: `juevesdelaciencia|COL0008423|event|2023`.
+
+`product_hash.py` es una copia sin cambios del de cvlac-json y gruplac-json; `tests/product_hash_vectors.json` fija
+su resultado en los tres paquetes.
+
+## Desarrollo
+
+```bash
+python -m pip install -e ".[dev]"
+python -m pytest
+ruff check . && ruff format --check .
+```
+
+Las versiones se publican en PyPI desde GitHub Actions al subir una etiqueta `v*`; ver
+[PUBLISHING.md](PUBLISHING.md) y [CHANGELOG.md](CHANGELOG.md).

cvgruplac_json-0.1.0/README.md

@@ -0,0 +1,106 @@
+# cvgruplac-json
+
+[![CI](https://github.com/restrepo/cvgruplac-json/actions/workflows/ci.yml/badge.svg)](https://github.com/restrepo/cvgruplac-json/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/cvgruplac-json.svg)](https://pypi.org/project/cvgruplac-json/)
+[![Python](https://img.shields.io/pypi/pyversions/cvgruplac-json.svg)](https://pypi.org/project/cvgruplac-json/)
+
+Une los JSON de [cvlac-json](https://github.com/restrepo/cvlac-json) (el CvLAC de una persona) y de
+[gruplac-json](https://github.com/restrepo/gruplac-json) (el GrupLAC de un grupo) de Minciencias: cada producto de
+los dos recibe un `id` y una lista `scrapping_ids` con sus ids en una y otra fuente, así que un producto del grupo
+apunta al mismo producto en el CV de cada integrante que lo firmó, y al revés.
+
+No descarga nada ni llama a ninguna API: lee los JSON que ya escribieron los dos paquetes y escribe copias unidas,
+sin tocar los originales. Solo usa la biblioteca estándar.
+
+## Instalación
+
+```bash
+pip install cvgruplac-json
+```
+
+## Uso
+
+```bash
+cvgruplac-json --cvlac cvlac/ --gruplac gruplac/ --out unidos/
+cvgruplac-json --cvlac cvlac_udea/ cvlac_colombia/json/ --gruplac gruplac/json/ --out unidos/ --workers 4
+cvgruplac-json --gruplac gruplac_COL0008423.json --cvlac cvlac_0000707619.json --out unidos/
+cvgruplac-json --gruplac gruplac/ --out unidos/        # sin CvLAC: ids de CvLAC sin verificar
+```
+
+- `--cvlac` y `--gruplac` reciben archivos o carpetas (`cvlac_*.json[.gz]`, `gruplac_*.json[.gz]`). Si un COD_RH o
+  un grupo está en más de una entrada, gana la primera.
+- Escribe `unidos/gruplac/` y `unidos/cvlac/` con el mismo nombre y compresión de cada entrada, y
+  `unidos/cvgruplac_summary.json` con los conteos y los archivos que no pudo leer. `--only gruplac` escribe solo los
+  GrupLAC.
+- Hace tres pasadas: lee los hashes de los CvLAC, une los GrupLAC y luego los CvLAC.
+
+En Python:
+
+```python
+from cvgruplac_json import link, link_gruplac, link_cvlac, id_hash
+
+index = link(gruplacs, cvlacs)  # listas de dicts de gruplac-json y cvlac-json, unidos en su lugar
+```
+
+## Los identificadores
+
+Cada producto (obras, proyectos, eventos, patentes y cada ítem de `other_products`) empieza con dos claves:
+
+```json
+"id": "efc8d0bb2fa50a617767aa814a57a7a40c1c956f",
+"scrapping_ids": [
+  {"id": "efc8d0bb2fa50a617767aa814a57a7a40c1c956f", "source": "cvlac"},
+  {"id": "efc8d0bb2fa50a617767aa814a57a7a40c1c956f", "source": "gruplac"}
+]
+```
+
+**En un GrupLAC**
+
+- `source: "cvlac"`: una por integrante autor con `product_hash`, en el orden de los autores. Es el id del producto
+  en el CvLAC de ese integrante (el `product_hash` que cvlac-json pone en la entrada del dueño). Si el CvLAC del
+  integrante está entre las entradas, se pone solo si el producto está en él; si no está, se pone con
+  `"verified": false`. No hay ninguna en las secciones que solo tiene el GrupLAC
+  ([`data/sections.json`](src/cvgruplac_json/data/sections.json)), ni en proyectos y eventos, que el GrupLAC lista
+  sin autores.
+- `source: "gruplac"`, siempre la última: el primer id de CvLAC si lo hay, así que un producto que está en los dos
+  tiene el mismo id. Si no, el SHA-1 de `título|código COL|tipo|año` (abajo).
+- `id` es el de `source: "gruplac"`.
+
+**En un CvLAC**
+
+- `source: "cvlac"`: el `product_hash` del dueño. Los productos sin él (los eventos) usan el SHA-1 de
+  `título|COD_RH|event|año`.
+- `source: "gruplac"`, con `group` (código COL): una por cada producto de un GrupLAC que lo lista como id de CvLAC
+  verificado. Un artículo del CV que está en dos grupos tiene dos.
+- `id` es el de `source: "cvlac"` y reemplaza el `id` por posición de cvlac-json (`cvlac:COD_RH:n`).
+
+**El hash.** `id_hash(título, dueño, tipo, año, n)` es la receta del `product_hash` con el dueño que corresponda: el
+SHA-1 de
+
+```
+<título>|<dueño>|<tipo>|<año>
+```
+
+- título en minúsculas, sin tildes y solo con letras y dígitos; un ítem sin título usa su nombre (eventos) o su texto;
+- dueño: el código COL del grupo (el número GrupLAC de 14 dígitos si no tiene), o el COD_RH con 10 dígitos (con un
+  COD_RH y los tipos `work`, `project`, `patent` y `other` da exactamente el `product_hash`);
+- tipo: `work`, `project`, `event`, `patent` u `other`;
+- año: `year_published`, `year`, el año de `start` o el de `date`.
+
+Si varios productos del mismo JSON dan la misma clave, el n-ésimo, en el orden de la página, lleva `|n` al final; y
+un candidato ya usado en ese JSON pasa al siguiente `n`. Por eso `id` es único dentro de cada GrupLAC y de cada
+CvLAC. Ejemplo de clave de un evento: `juevesdelaciencia|COL0008423|event|2023`.
+
+`product_hash.py` es una copia sin cambios del de cvlac-json y gruplac-json; `tests/product_hash_vectors.json` fija
+su resultado en los tres paquetes.
+
+## Desarrollo
+
+```bash
+python -m pip install -e ".[dev]"
+python -m pytest
+ruff check . && ruff format --check .
+```
+
+Las versiones se publican en PyPI desde GitHub Actions al subir una etiqueta `v*`; ver
+[PUBLISHING.md](PUBLISHING.md) y [CHANGELOG.md](CHANGELOG.md).

cvgruplac_json-0.1.0/pyproject.toml

@@ -0,0 +1,67 @@
+[build-system]
+requires = ["hatchling>=1.24", "hatch-vcs>=0.4"]
+build-backend = "hatchling.build"
+
+[project]
+name = "cvgruplac-json"
+dynamic = ["version"]
+description = "Link the JSONs of cvlac-json and gruplac-json: one id per product, in both directions."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{ name = "Diego Restrepo", email = "restrepo@udea.edu.co" }]
+keywords = []
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "pytest-cov>=5", "ruff==0.17.3", "build>=1.2", "twine>=5"]
+
+[project.scripts]
+cvgruplac-json = "cvgruplac_json.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/restrepo/cvgruplac-json"
+Repository = "https://github.com/restrepo/cvgruplac-json"
+Issues = "https://github.com/restrepo/cvgruplac-json/issues"
+Changelog = "https://github.com/restrepo/cvgruplac-json/blob/main/CHANGELOG.md"
+
+# Version from the git tag (v0.1.0 -> 0.1.0); commits after a tag get 0.1.1.devN
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.version.raw-options]
+local_scheme = "no-local-version"   # PyPI and TestPyPI reject local versions (+g1234abc)
+
+[tool.hatch.build.targets.sdist]
+include = ["src/", "tests/", "README.md", "CHANGELOG.md", "LICENSE"]  # src/ includes data/sections.json
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/cvgruplac_json"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra --strict-markers"
+
+[tool.coverage.run]
+source = ["cvgruplac_json"]
+branch = true
+
+[tool.ruff]
+line-length = 130
+target-version = "py310"
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "B", "UP", "SIM", "RUF"]
+ignore = [
+    "RUF001", "RUF002", "RUF003",  # Spanish text with accents and typographic quotes (and product_hash.py, a verbatim copy)
+]

cvgruplac_json-0.1.0/src/cvgruplac_json/__init__.py

@@ -0,0 +1,13 @@
+"""Link the JSONs of cvlac-json and gruplac-json: one id per product, in both directions."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from .link import id_hash, id_key, link, link_cvlac, link_gruplac
+from .product_hash import product_hash
+
+try:
+    __version__ = version("cvgruplac-json")
+except PackageNotFoundError:  # running from a source tree that was never installed
+    __version__ = "0.0.0"
+
+__all__ = ["__version__", "id_hash", "id_key", "link", "link_cvlac", "link_gruplac", "product_hash"]

cvgruplac_json-0.1.0/src/cvgruplac_json/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

cvgruplac_json-0.1.0/src/cvgruplac_json/cli.py

@@ -0,0 +1,158 @@
+"""Command line entry point: `cvgruplac-json`.
+
+    cvgruplac-json --cvlac CVLAC_DIR [...] --gruplac GRUPLAC_DIR [...] --out OUT_DIR [--workers N] [--only gruplac]
+
+Inputs are folders (their cvlac_*.json[.gz] or gruplac_*.json[.gz] files) or single files. Three passes:
+1. read every CvLAC and keep its owner's product_hashes;
+2. link every GrupLAC (link_gruplac) and write it to OUT/gruplac/;
+3. link every CvLAC (link_cvlac) with the GrupLAC products found in pass 2 and write it to OUT/cvlac/.
+Outputs keep the input's name and compression; inputs are not changed. OUT/cvgruplac_summary.json has the counts.
+"""
+
+import argparse
+import gzip
+import json
+import multiprocessing as mp
+import os
+import re
+import sys
+import time
+from collections import Counter
+from pathlib import Path
+
+from . import __version__
+from .link import link_cvlac, link_gruplac, owner_hashes
+
+_STATE = {}  # shared with forked workers: hashes, cods, index, out
+
+
+def _files(paths, prefix):
+    """{key: path} for cvlac_<COD>.json[.gz] or gruplac_<CODE>.json[.gz]; the first path given wins."""
+    out = {}
+    for p in map(Path, paths):
+        cands = sorted(p.glob(f"{prefix}_*.json")) + sorted(p.glob(f"{prefix}_*.json.gz")) if p.is_dir() else [p]
+        for f in cands:
+            m = re.match(rf"{prefix}_(.+?)\.json(\.gz)?$", f.name)
+            out.setdefault(m.group(1) if m else f.name, f)
+    return out
+
+
+def _read(path):
+    with (gzip.open if path.suffix == ".gz" else open)(path, "rt", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _write(data, path):
+    tmp = path.with_name(path.name + ".tmp")
+    gz = {"compresslevel": 6} if path.suffix == ".gz" else {}  # gzip's default 9 is several times slower
+    with (gzip.open if gz else open)(tmp, "wt", encoding="utf-8", **gz) as f:
+        json.dump(data, f, ensure_ascii=False, separators=(",", ":"))
+    os.replace(tmp, path)
+
+
+def _hashes(path):
+    try:
+        d = _read(path)
+        return d["cod_rh"], owner_hashes(d), None
+    except Exception as e:
+        return None, set(), f"{path}: {type(e).__name__}: {e}"
+
+
+def _gruplac(path):
+    try:
+        d = _read(path)
+        matches = link_gruplac(d, _STATE["hashes"], _STATE["cods"])
+        d["cvgruplac"] = {"version": __version__, "cvlac_checked": _STATE["cods"] is not None}
+        _write(d, _STATE["out"] / "gruplac" / path.name)
+        c = Counter({k: v for k, v in d["counts"].items() if k.startswith(("products_", "cvlac_ids_"))})
+        return matches, c + Counter(gruplacs=1), None
+    except Exception as e:
+        return [], Counter(), f"{path}: {type(e).__name__}: {e}"
+
+
+def _cvlac(path):
+    try:
+        d = _read(path)
+        link_cvlac(d, _STATE["index"])
+        d["cvgruplac"] = {"version": __version__}
+        _write(d, _STATE["out"] / "cvlac" / path.name)
+        return Counter(cvlac_products_in_gruplac=d["counts"]["products_in_gruplac"], cvlacs=1), None
+    except Exception as e:
+        return Counter(), f"{path}: {type(e).__name__}: {e}"
+
+
+def _map(fn, items, workers, label, log):
+    """Results of fn over items, with forked workers when possible (they share _STATE without copying it)."""
+    t0, n = time.time(), len(items)
+    if workers > 1 and "fork" in mp.get_all_start_methods():
+        pool = mp.get_context("fork").Pool(workers)
+        it = pool.imap_unordered(fn, items, chunksize=16)
+    else:
+        pool, it = None, map(fn, items)
+    try:
+        for i, r in enumerate(it, 1):
+            if i % 5000 == 0 or i == n:
+                log(f"{label}: {i}/{n} ({time.time() - t0:.0f} s)")
+            yield r
+    finally:
+        if pool:
+            pool.close()
+            pool.join()
+
+
+def run(cvlac, gruplac, out, workers=4, only=None, log=print):
+    """Link the files or folders given; returns the summary also written to OUT/cvgruplac_summary.json."""
+    out = Path(out)
+    cv, gr = _files(cvlac or [], "cvlac"), _files(gruplac or [], "gruplac")
+    log(f"{len(cv)} CvLAC and {len(gr)} GrupLAC files")
+    errors, cods, hashes = [], set(), set()
+    for cod, hs, err in _map(_hashes, list(cv.values()), workers, "1/3 CvLAC hashes", log):
+        if err:
+            errors.append(err)
+        else:
+            cods.add(cod)
+            hashes |= hs
+    _STATE.update(hashes=hashes, cods=cods if cv else None, out=out, index={})
+    (out / "gruplac").mkdir(parents=True, exist_ok=True)
+    total = Counter()
+    for matches, c, err in _map(_gruplac, list(gr.values()), workers, "2/3 GrupLAC", log):
+        errors += [err] if err else []
+        total += c
+        for h, group, gid in matches:
+            _STATE["index"].setdefault(h, []).append((group, gid))
+    if only != "gruplac" and cv:
+        (out / "cvlac").mkdir(parents=True, exist_ok=True)
+        for c, err in _map(_cvlac, list(cv.values()), workers, "3/3 CvLAC", log):
+            errors += [err] if err else []
+            total += c
+    summary = {"version": __version__, "cvlac_files": len(cv), "gruplac_files": len(gr), **total, "errors": errors}
+    out.mkdir(parents=True, exist_ok=True)
+    _write(summary, out / "cvgruplac_summary.json")
+    _STATE.clear()
+    return summary
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(
+        prog="cvgruplac-json",
+        description="Link the JSONs of cvlac-json and gruplac-json: one id per product, in both directions.",
+        epilog="Example: cvgruplac-json --cvlac cvlac_json/ --gruplac gruplac_json/ --out linked/",
+    )
+    ap.add_argument("--cvlac", nargs="+", default=[], metavar="PATH", help="cvlac-json files or folders")
+    ap.add_argument("--gruplac", nargs="+", default=[], metavar="PATH", help="gruplac-json files or folders")
+    ap.add_argument("--out", required=True, help="output folder (gruplac/, cvlac/, cvgruplac_summary.json)")
+    ap.add_argument("--workers", type=int, default=min(4, os.cpu_count() or 1), help="processes (default: up to 4)")
+    ap.add_argument("--only", choices=["gruplac"], help="write only the linked GrupLACs")
+    ap.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    a = ap.parse_args(argv)
+    if not a.gruplac and not a.cvlac:
+        ap.error("give --gruplac and/or --cvlac")
+    s = run(a.cvlac, a.gruplac, a.out, a.workers, a.only, log=lambda m: print(m, file=sys.stderr))
+    print(json.dumps({k: v for k, v in s.items() if k != "errors"} | {"errors": len(s["errors"])}, indent=1))
+    for e in s["errors"][:20]:
+        print(e, file=sys.stderr)
+    return 1 if s["errors"] else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())