icat-sync-parametertype 1.0.0__tar.gz

icat_sync_parametertype-1.0.0/LICENSE.md

@@ -0,0 +1,20 @@
+# MIT License
+
+**Copyright (c) 2024 European Synchrotron Radiation Facility**
+
+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.

icat_sync_parametertype-1.0.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: icat-sync-parametertype
+Version: 1.0.0
+Summary: Python client to synchronize parameterType from the icat-esrf-definitions with the ICAT database
+Author-email: ESRF <marjolaine.bodin@esrf.fr>
+License: # MIT License
+        
+        **Copyright (c) 2024 European Synchrotron Radiation Facility**
+        
+        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.
+        
+Project-URL: Homepage, https://gitlab.esrf.fr/icat/data-sync/parametertype
+Project-URL: Documentation, https://gitlab.esrf.fr/icat/data-sync/parametertype
+Project-URL: Repository, https://gitlab.esrf.fr/icat/data-sync/parametertype
+Project-URL: Issues, https://gitlab.esrf.fr/icat/data-sync/parametertype/issues
+Project-URL: Changelog, https://gitlab.esrf.fr/icat/data-sync/parametertype/-/blob/main/CHANGELOG.md
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: python-icat
+Requires-Dist: icat-esrf-definitions
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: dev
+Requires-Dist: icat-sync-parametertype[test]; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# icat-sync-parametertype
+
+A python client to synchronize the metadata defined in the [ICAT ESRF definitions](https://gitlab.esrf.fr/icat/hdf5-master-config) with the ICAT database.
+
+```bash
+icat-sync-parametertype -w http://ovm-icat-test.esrf.fr:8080 -a db -u admin -P
+```
+
+`-P` prompts for the password. The connection can also be read from a
+[python-icat configuration file](https://python-icat.readthedocs.io/en/stable/config.html)
+(`icat.cfg`, or the file given by the `ICAT_CFG` environment variable), selecting a section with `-s`.
+Copy [icat.cfg.example](icat.cfg.example) to `icat.cfg` and fill in the credentials:
+
+```bash
+icat-sync-parametertype -s test
+```
+
+## Options
+
+- `--dry-run`: only show the changes, nothing is registered in ICAT.
+- `--yes`: register the changes without asking for confirmation (for CI).
+
+## Exit codes
+
+| Code | Meaning |
+|------|---------|
+| 0 | ICAT is up to date, or the changes were registered (or declined) |
+| 1 | At least one change failed to be registered |
+| 2 | `--dry-run` detected changes |

icat_sync_parametertype-1.0.0/README.md

@@ -0,0 +1,29 @@
+# icat-sync-parametertype
+
+A python client to synchronize the metadata defined in the [ICAT ESRF definitions](https://gitlab.esrf.fr/icat/hdf5-master-config) with the ICAT database.
+
+```bash
+icat-sync-parametertype -w http://ovm-icat-test.esrf.fr:8080 -a db -u admin -P
+```
+
+`-P` prompts for the password. The connection can also be read from a
+[python-icat configuration file](https://python-icat.readthedocs.io/en/stable/config.html)
+(`icat.cfg`, or the file given by the `ICAT_CFG` environment variable), selecting a section with `-s`.
+Copy [icat.cfg.example](icat.cfg.example) to `icat.cfg` and fill in the credentials:
+
+```bash
+icat-sync-parametertype -s test
+```
+
+## Options
+
+- `--dry-run`: only show the changes, nothing is registered in ICAT.
+- `--yes`: register the changes without asking for confirmation (for CI).
+
+## Exit codes
+
+| Code | Meaning |
+|------|---------|
+| 0 | ICAT is up to date, or the changes were registered (or declined) |
+| 1 | At least one change failed to be registered |
+| 2 | `--dry-run` detected changes |

icat_sync_parametertype-1.0.0/pyproject.toml

@@ -0,0 +1,76 @@
+[build-system]
+requires = ["setuptools>=46.4"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "icat-sync-parametertype"
+version = "1.0.0"
+authors = [{name = "ESRF", email = "marjolaine.bodin@esrf.fr"}]
+description = "Python client to synchronize parameterType from the icat-esrf-definitions with the ICAT database"
+readme = {file = "README.md", content-type = "text/markdown"}
+license = {file = "LICENSE.md"}
+classifiers = [
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+]
+requires-python = ">=3.8"
+dependencies = [
+    "python-icat",
+    "icat-esrf-definitions",
+]
+
+
+[project.optional-dependencies]
+test = [
+    "pytest"
+]
+dev = [
+    "icat-sync-parametertype[test]",
+    "ruff"
+]
+
+[project.urls]
+Homepage = "https://gitlab.esrf.fr/icat/data-sync/parametertype"
+Documentation = "https://gitlab.esrf.fr/icat/data-sync/parametertype"
+Repository = "https://gitlab.esrf.fr/icat/data-sync/parametertype"
+Issues = "https://gitlab.esrf.fr/icat/data-sync/parametertype/issues"
+Changelog = "https://gitlab.esrf.fr/icat/data-sync/parametertype/-/blob/main/CHANGELOG.md"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"*"= ['*.txt', '*.json']
+
+[tool.coverage.run]
+omit = ['*/tests/*']
+
+[tool.ruff]
+line-length = 88
+
+[tool.ruff.lint]
+select = [
+    "E", # pycodestyle errors
+    "F", # pyflakes
+    "I", # isort
+    "N", # pep8-naming
+    "S", # flake8-bandit
+]
+ignore = ["E501"]
+
+[tool.ruff.lint.per-file-ignores]
+"**/tests/**" = [
+    "S101", # allow asserts
+]
+
+[tool.ruff.lint.isort]
+force-single-line = true
+known-first-party = ["icat_sync_parametertype"]
+
+
+[project.scripts]
+icat-sync-parametertype = "icat_sync_parametertype.apps.sync:main"

icat_sync_parametertype-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

icat_sync_parametertype-1.0.0/src/icat_sync_parametertype/apps/sync.py

@@ -0,0 +1,37 @@
+import logging
+import sys
+
+from icat_sync_parametertype.definition import get_icat_esrf_definition
+from icat_sync_parametertype.icat_client import get_icat_parametertype
+from icat_sync_parametertype.icat_client import setup_icat_client
+from icat_sync_parametertype.icat_client import sync_parametertypes
+from icat_sync_parametertype.logger import setup_logging
+
+logger = logging.getLogger(__name__)
+
+
+def main() -> int:
+    setup_logging(level=logging.DEBUG)
+    client, conf = setup_icat_client()
+
+    logger.info("=" * 60)
+    logger.info("ICAT environment: %s", conf.configSection or "(command line)")
+    logger.info("ICAT server:      %s", client.url)
+    logger.info("ICAT user:        %s/%s", conf.auth, getattr(conf, "username", "-"))
+    logger.info("=" * 60)
+
+    logger.info("Updating ICAT parameterTypes using the ESRF icat definitions...")
+    icat_parametertypes = get_icat_parametertype(client)
+
+    metadata = get_icat_esrf_definition()
+    logger.info(f"Retrieved {len(metadata)} parameter types in ICAT ESRF definition")
+
+    exit_code = sync_parametertypes(
+        icat_parametertypes, metadata, client, dry_run=conf.dry_run, yes=conf.yes
+    )
+    logger.info("Synchronization finished.")
+    return exit_code
+
+
+if __name__ == "__main__":
+    sys.exit(main())

icat_sync_parametertype-1.0.0/src/icat_sync_parametertype/definition.py

@@ -0,0 +1,17 @@
+from typing import Dict
+
+from icat_esrf_definitions.models import IcatDatasetParameters
+
+
+def get_icat_esrf_definition() -> Dict[str, Dict[str, str]]:
+    fields = IcatDatasetParameters.icat_fields()
+    metadata = {}
+    for field in fields.values():
+        units = str(field.unit_info.units) if field.unit_info else ""
+
+        metadata[field.icat_name] = {
+            "description": field.description or "",
+            "units": units,
+            "rename_to": field.new_icat_name,
+        }
+    return metadata

icat_sync_parametertype-1.0.0/src/icat_sync_parametertype/icat_client.py

@@ -0,0 +1,288 @@
+import logging
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Tuple
+
+import icat
+import icat.config
+from icat.entity import Entity
+from icat.query import Query
+
+logger = logging.getLogger(__name__)
+
+
+def setup_icat_client() -> Tuple[icat.client.Client, icat.config.Configuration]:
+    config = icat.config.Config(ids=False)
+    config.add_variable(
+        "dry_run",
+        ("--dry-run",),
+        dict(help="only show the changes, exit with code 2 if there are any"),
+        type=icat.config.flag,
+        default=False,
+    )
+    config.add_variable(
+        "yes",
+        ("--yes",),
+        dict(help="register the changes without asking for confirmation"),
+        type=icat.config.flag,
+        default=False,
+    )
+    client, conf = config.getconfig()
+    client.login(conf.auth, conf.credentials)
+    return client, conf
+
+
+def get_icat_parametertype(icat_client: icat.client.Client) -> List[Dict]:
+    try:
+        query = Query(icat_client, "ParameterType")
+        icat_parametertype = icat_client.search(query)
+        logger.info(
+            "Retrieved " + str(len(icat_parametertype)) + " parameterTypes in ICAT"
+        )
+        return icat_parametertype
+    except icat.SearchResultError as e:
+        logger.error(e)
+        return []
+
+
+def is_parametertype_changed(
+    parametertype: Entity, new_description: str, new_units: str
+) -> bool:
+    current_description = parametertype.description or ""
+    current_units = getattr(parametertype, "units", "") or ""
+    return current_description != new_description or current_units != new_units
+
+
+def update_parametertype(
+    client: icat.client.Client,
+    esrf_facility: Entity,
+    name: str,
+    description: str,
+    units: str,
+    register: bool,
+) -> bool:
+    try:
+        query = Query(client, "ParameterType", conditions={"name": "= '%s'" % name})
+        parametertype = client.assertedSearch(query)[0]
+    except icat.SearchResultError as e:
+        logger.error(e)
+        return False
+
+    if is_parametertype_changed(parametertype, description, units):
+        try:
+            parametertype.facility = esrf_facility
+            parametertype.applicableToDataCollection = (
+                parametertype.applicableToDataCollection
+            )
+            parametertype.applicableToDatafile = parametertype.applicableToDatafile
+            parametertype.applicableToDataset = parametertype.applicableToDataset
+            parametertype.applicableToInvestigation = (
+                parametertype.applicableToInvestigation
+            )
+            parametertype.applicableToSample = parametertype.applicableToSample
+            parametertype.applicableToSample = parametertype.applicableToSample
+            parametertype.maximumNumericValue = parametertype.maximumNumericValue
+            parametertype.minimumNumericValue = parametertype.minimumNumericValue
+            parametertype.unitsFullName = parametertype.unitsFullName
+            parametertype.valueType = parametertype.valueType
+
+            parametertype.description = description
+            parametertype.units = units
+
+            if register:
+                parametertype.update()
+            logger.info(
+                "ParameterType %s updated with description=%s unit=%s",
+                name,
+                description,
+                units,
+            )
+        except Exception as e:
+            logger.error("Failed to update ParameterType %s: %s", name, e)
+            return False
+    return True
+
+
+def rename_parametertype(
+    client: icat.client.Client,
+    esrf_facility: Entity,
+    old_name: str,
+    new_name: str,
+    register: bool,
+) -> bool:
+    try:
+        query = Query(client, "ParameterType", conditions={"name": "= '%s'" % old_name})
+        parametertype = client.assertedSearch(query)[0]
+    except icat.SearchResultError as e:
+        logger.error(e)
+        return False
+    try:
+        parametertype.facility = esrf_facility
+        parametertype.applicableToDataCollection = (
+            parametertype.applicableToDataCollection
+        )
+        parametertype.applicableToDatafile = parametertype.applicableToDatafile
+        parametertype.applicableToDataset = parametertype.applicableToDataset
+        parametertype.applicableToInvestigation = (
+            parametertype.applicableToInvestigation
+        )
+        parametertype.applicableToSample = parametertype.applicableToSample
+        parametertype.applicableToSample = parametertype.applicableToSample
+        parametertype.maximumNumericValue = parametertype.maximumNumericValue
+        parametertype.minimumNumericValue = parametertype.minimumNumericValue
+        parametertype.unitsFullName = parametertype.unitsFullName
+        parametertype.valueType = parametertype.valueType
+
+        parametertype.description = parametertype.description
+        parametertype.units = parametertype.units
+
+        parametertype.name = new_name
+
+        if register:
+            parametertype.update()
+        logger.info("ParameterType %s renamed with name=%s", old_name, new_name)
+    except Exception as e:
+        logger.error("Failed to rename ParameterType %s: %s", old_name, e)
+        return False
+    return True
+
+
+def create_parametertype(
+    client: icat.client.Client,
+    esrf_facility: Entity,
+    name: str,
+    description: str,
+    units: str,
+    register: bool,
+) -> bool:
+    try:
+        parametertype = client.new(
+            "ParameterType",
+            name=name,
+            facility=esrf_facility,
+            description=description,
+            units=units,
+            applicableToDataset=True,
+            valueType="STRING",
+        )
+        if register:
+            parametertype.create()
+        logger.info(
+            "ParameterType %s created with description=%s units=%s",
+            name,
+            description,
+            units,
+        )
+    except icat.ICATObjectExistsError:
+        logger.error("Error while creating the parametertype %s", name)
+        return False
+    return True
+
+
+def get_facility(client: icat.client.Client) -> Entity:
+    return client.assertedSearch("Facility[name='ESRF']")[0]
+
+
+def truncate_for_oracle(
+    value: str, max_bytes: int = 255, encoding: str = "utf-8"
+) -> str:
+    if value is None:
+        return ""
+    encoded = value.encode(encoding)
+    if len(encoded) <= max_bytes:
+        return value
+    return encoded[:max_bytes].decode(encoding, errors="ignore")
+
+
+def sync_parametertypes(
+    icat_parametertypes: List[Any],
+    metadata: Dict[str, Dict[str, str]],
+    icat_client: icat.client.Client,
+    dry_run: bool = False,
+    yes: bool = False,
+) -> int:
+    """Return the exit code: 0 on success or nothing to do, 1 if an operation
+    failed, 2 if changes are detected in dry-run mode."""
+    icat_by_name = {p.name: p for p in icat_parametertypes}
+    esrf_facility = get_facility(icat_client)
+    operations = []
+
+    for name, field in metadata.items():
+        new_name = field.get("rename_to")
+        if new_name and name in icat_by_name:
+            operations.append(("rename", name, new_name))
+            icat_by_name[new_name] = icat_by_name.pop(name)
+
+    for name, field in metadata.items():
+        if field.get("rename_to") in metadata:
+            continue
+        description = field.get("description") or ""
+        description = truncate_for_oracle(description)
+        units = field.get("units") or "NA"
+        target_name = field.get("rename_to") or name
+
+        if target_name in icat_by_name:
+            param = icat_by_name[target_name]
+            if is_parametertype_changed(param, description, units):
+                operations.append(("update", target_name, description, units))
+        else:
+            operations.append(("create", target_name, description, units))
+
+    if not operations:
+        logger.info("ICAT is up to date, no changes detected.")
+        return 0
+
+    logger.info("The following changes are detected:")
+    for op in operations:
+        if op[0] == "rename":
+            logger.info(f"  - Rename '{op[1]}' -> '{op[2]}'")
+        elif op[0] == "update":
+            logger.info(f"  - Update '{op[1]}' (description/units changed)")
+        elif op[0] == "create":
+            logger.info(f"  - Create '{op[1]}'")
+
+    if dry_run:
+        logger.warning("Dry run: no changes will be registered into ICAT!")
+        return 2
+    if yes:
+        register = True
+    else:
+        response = (
+            input(
+                f"Do you want to register these changes into ICAT {icat_client.url}? [y/N]: "
+            )
+            .strip()
+            .lower()
+        )
+        register = response == "y"
+    if not register:
+        logger.warning("No changes will be registered into ICAT!")
+        return 0
+
+    failures = 0
+
+    for op in operations:
+        if op[0] == "rename":
+            _, old, new = op
+            ok = rename_parametertype(icat_client, esrf_facility, old, new, register)
+
+        elif op[0] == "update":
+            _, name, description, units = op
+            ok = update_parametertype(
+                icat_client, esrf_facility, name, description, units, register
+            )
+
+        elif op[0] == "create":
+            _, name, description, units = op
+            ok = create_parametertype(
+                icat_client, esrf_facility, name, description, units, register
+            )
+
+        if not ok:
+            failures += 1
+
+    if failures:
+        logger.error("%d of %d changes failed", failures, len(operations))
+        return 1
+    return 0

icat_sync_parametertype-1.0.0/src/icat_sync_parametertype/logger.py

@@ -0,0 +1,19 @@
+import logging
+import sys
+
+
+def setup_logging(level=logging.INFO) -> None:
+    formatter = logging.Formatter(
+        "[%(asctime)s] [%(levelname)s] [%(name)s]: %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(formatter)
+
+    root_logger = logging.getLogger()
+    root_logger.setLevel(logging.WARNING)
+    root_logger.handlers.clear()
+    root_logger.addHandler(handler)
+
+    logging.getLogger("icat_sync_parametertype").setLevel(level)

icat_sync_parametertype-1.0.0/src/icat_sync_parametertype/tests/test_sync.py

@@ -0,0 +1,86 @@
+from types import SimpleNamespace
+
+import pytest
+
+from icat_sync_parametertype import icat_client
+
+
+def param(name, description="desc", units="NA"):
+    return SimpleNamespace(name=name, description=description, units=units)
+
+
+def field(description="desc", units="", rename_to=None):
+    return {"description": description, "units": units, "rename_to": rename_to}
+
+
+@pytest.fixture
+def calls(monkeypatch):
+    """Record the ICAT operations instead of sending them."""
+    calls = []
+    monkeypatch.setattr(icat_client, "get_facility", lambda client: None)
+
+    def recorder(op):
+        def record(client, facility, *args):
+            calls.append((op, *args[:-1]))  # drop the register flag
+            return True
+
+        return record
+
+    for op in ("create", "update", "rename"):
+        monkeypatch.setattr(icat_client, f"{op}_parametertype", recorder(op))
+    return calls
+
+
+def sync(icat_params, metadata, **kwargs):
+    client = SimpleNamespace(url="https://icat.test")
+    return icat_client.sync_parametertypes(icat_params, metadata, client, **kwargs)
+
+
+def test_up_to_date(calls):
+    assert sync([param("A")], {"A": field()}, yes=True) == 0
+    assert calls == []
+
+
+def test_create_and_update(calls):
+    metadata = {"A": field(description="new"), "B": field(units="mm")}
+    assert sync([param("A")], metadata, yes=True) == 0
+    assert calls == [("update", "A", "new", "NA"), ("create", "B", "desc", "mm")]
+
+
+def test_rename_uses_new_entry_values(calls):
+    metadata = {
+        "old": field(description="old desc", rename_to="new"),
+        "new": field(description="new desc"),
+    }
+    assert sync([param("old", description="new desc")], metadata, yes=True) == 0
+    assert calls == [("rename", "old", "new")]
+
+
+def test_renamed_field_is_stable(calls):
+    metadata = {
+        "old": field(description="old desc", rename_to="new"),
+        "new": field(description="new desc"),
+    }
+    assert sync([param("new", description="new desc")], metadata, yes=True) == 0
+    assert calls == []
+
+
+def test_quotes_are_not_doubled(calls):
+    sync([], {"A": field(description="it's")}, yes=True)
+    assert calls == [("create", "A", "it's", "NA")]
+
+
+def test_dry_run(calls):
+    assert sync([], {"A": field()}, dry_run=True) == 2
+    assert calls == []
+
+
+def test_failure(calls, monkeypatch):
+    monkeypatch.setattr(icat_client, "create_parametertype", lambda *args: False)
+    assert sync([], {"A": field()}, yes=True) == 1
+
+
+def test_declined(calls, monkeypatch):
+    monkeypatch.setattr("builtins.input", lambda prompt: "n")
+    assert sync([], {"A": field()}) == 0
+    assert calls == []

icat_sync_parametertype-1.0.0/src/icat_sync_parametertype.egg-info/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: icat-sync-parametertype
+Version: 1.0.0
+Summary: Python client to synchronize parameterType from the icat-esrf-definitions with the ICAT database
+Author-email: ESRF <marjolaine.bodin@esrf.fr>
+License: # MIT License
+        
+        **Copyright (c) 2024 European Synchrotron Radiation Facility**
+        
+        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.
+        
+Project-URL: Homepage, https://gitlab.esrf.fr/icat/data-sync/parametertype
+Project-URL: Documentation, https://gitlab.esrf.fr/icat/data-sync/parametertype
+Project-URL: Repository, https://gitlab.esrf.fr/icat/data-sync/parametertype
+Project-URL: Issues, https://gitlab.esrf.fr/icat/data-sync/parametertype/issues
+Project-URL: Changelog, https://gitlab.esrf.fr/icat/data-sync/parametertype/-/blob/main/CHANGELOG.md
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: python-icat
+Requires-Dist: icat-esrf-definitions
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: dev
+Requires-Dist: icat-sync-parametertype[test]; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# icat-sync-parametertype
+
+A python client to synchronize the metadata defined in the [ICAT ESRF definitions](https://gitlab.esrf.fr/icat/hdf5-master-config) with the ICAT database.
+
+```bash
+icat-sync-parametertype -w http://ovm-icat-test.esrf.fr:8080 -a db -u admin -P
+```
+
+`-P` prompts for the password. The connection can also be read from a
+[python-icat configuration file](https://python-icat.readthedocs.io/en/stable/config.html)
+(`icat.cfg`, or the file given by the `ICAT_CFG` environment variable), selecting a section with `-s`.
+Copy [icat.cfg.example](icat.cfg.example) to `icat.cfg` and fill in the credentials:
+
+```bash
+icat-sync-parametertype -s test
+```
+
+## Options
+
+- `--dry-run`: only show the changes, nothing is registered in ICAT.
+- `--yes`: register the changes without asking for confirmation (for CI).
+
+## Exit codes
+
+| Code | Meaning |
+|------|---------|
+| 0 | ICAT is up to date, or the changes were registered (or declined) |
+| 1 | At least one change failed to be registered |
+| 2 | `--dry-run` detected changes |

icat_sync_parametertype-1.0.0/src/icat_sync_parametertype.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE.md
+README.md
+pyproject.toml
+src/icat_sync_parametertype/__init__.py
+src/icat_sync_parametertype/definition.py
+src/icat_sync_parametertype/icat_client.py
+src/icat_sync_parametertype/logger.py
+src/icat_sync_parametertype.egg-info/PKG-INFO
+src/icat_sync_parametertype.egg-info/SOURCES.txt
+src/icat_sync_parametertype.egg-info/dependency_links.txt
+src/icat_sync_parametertype.egg-info/entry_points.txt
+src/icat_sync_parametertype.egg-info/requires.txt
+src/icat_sync_parametertype.egg-info/top_level.txt
+src/icat_sync_parametertype/apps/__init__.py
+src/icat_sync_parametertype/apps/sync.py
+src/icat_sync_parametertype/tests/__init__.py
+src/icat_sync_parametertype/tests/test_sync.py

icat_sync_parametertype-1.0.0/src/icat_sync_parametertype.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

icat_sync_parametertype-1.0.0/src/icat_sync_parametertype.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+icat-sync-parametertype = icat_sync_parametertype.apps.sync:main

icat_sync_parametertype-1.0.0/src/icat_sync_parametertype.egg-info/requires.txt

@@ -0,0 +1,9 @@
+python-icat
+icat-esrf-definitions
+
+[dev]
+icat-sync-parametertype[test]
+ruff
+
+[test]
+pytest

icat_sync_parametertype-1.0.0/src/icat_sync_parametertype.egg-info/top_level.txt

@@ -0,0 +1 @@
+icat_sync_parametertype