fair-cli 0.9.9__tar.gz → 0.10.1__tar.gz

fair_cli-0.10.1/CHANGELOG.md

@@ -0,0 +1,132 @@
+# 2026-10-05 [v0.10.1](https://github.com/FAIRDataPipeline/FAIR-CLI/releases/tag/v0.10.1)
+
+## Changed behaviour
+- A wildcard entry keeps to one namespace: the one its `use:` names, else the default for its block. It
+  used to match names in every namespace, so a `write:` pattern could write a name into a namespace
+  other than its own.
+- A wildcard entry gives one entry for each name it matches: for a `read:`, the version its `use:` names,
+  else the highest; for a `write:`, the version to be written. It used to give one for every version, and
+  to ignore a version on a `read:`. A `read:` pattern that matches nothing is not an error.
+- `fair run` refuses a `read:` of a data product, or of a version of one, that is not in the registry,
+  naming the namespace and registry it looked in. Such a read used to pass unchecked, or as version 0.0.0.
+- `fair push` fails if a file cannot be uploaded. It used to warn and carry on, leaving the remote with
+  the file's records and no file. A file is now uploaded before its records are written, so a push that
+  failed can be run again.
+- `fair pull` checks each file it fetches against the hash the remote registry holds for it, and refuses
+  one that differs.
+
+## Added
+- Registering an external object records where its file was fetched from: the `root` and `path` of its
+  `register:` entry, as the object's `original_store`, with the hash of the file found there. `fair push`
+  takes that record to the remote. A file registered from the machine itself has no such record.
+- `fair push` takes a refusal of an upload address with HTTP 409 to mean that the remote's store already
+  holds the file, sends nothing, and carries on. No released registry answers so yet.
+
+## Fixed
+- `fair push` sent no value that was false, leaving the remote to apply its default: an external object
+  registered with `primary: false` arrived as primary, and a location with `public: false` as public.
+- A list from a registry stopped at its first 100 rows, so wildcards, staging and version lookups went
+  wrong, with no message, in a registry holding more.
+- `fair pull` looked for the version of a `read:` entry in the local registry only, so an entry at the
+  default version, for something not yet local, asked the remote for version 0.0.0 and failed.
+- `fair push` held each file whole in memory, `fair pull` more than twice over, and both left a copy of
+  it in the temporary directory. Files are now sent and received a block at a time, whatever their
+  size, and nothing is left behind.
+- An upload of 2 GiB or more over plain http failed on macOS.
+- An external object could not be registered with a `unique_name` and `alternate_identifier_type` in
+  place of an `identifier`: `fair pull` stopped, reporting that the object already existed.
+- `fair identify` looked at only the newest of a file's storage locations, so it could miss the data
+  products of a file the registry records in more than one place.
+- `fair run` could not start the script when the path of the data store, which holds the job
+  directory, had a space in it.
+
+## Development
+- The Python job of the implementations workflow starts an object store for its remote registry, so
+  that its `fair push` uploads the files. It had none, and passed while a failed upload was a warning.
+
+# 2026-10-03 [v0.10.0](https://github.com/FAIRDataPipeline/FAIR-CLI/releases/tag/v0.10.0)
+
+## Changed behaviour
+- `fair remote add` takes the remote's token file with `--token FILE`, and prompts for it if omitted.
+  The command never worked before: the label was stored as the token path.
+- `fair run --ci` prepares the job directory and prints it without running the script, as documented.
+- `fair init --ci` leaves an existing `.fair/` alone, as `fair init` does; it used to delete it, data
+  store included. Use `fair purge` to start afresh.
+- Wildcards: each `*` matches one segment of a name (not `/`), anchored at both ends, in `read:` and
+  `write:` alike, matching DataPipeline.jl. `data_product/*` no longer matches `data_product/1/2`.
+- `${{GIT_TAG}}` is the nearest tag in the history of the current commit (`git describe`), not the
+  last tag by name; with no such tag it is an error rather than a crash.
+- `run_metadata.shell` now chooses the interpreter the script runs with.
+
+## Fixed
+- `write:` entries with a wildcard were dropped from the working config (#140). The pattern is now kept
+  for new names, and existing matches are written as the pattern entry describes them (its `use: version`,
+  `file_type`, `description`).
+- `fair push` from a project whose data store was not the local registry's first storage root recorded
+  its files on the remote under the pusher's `file://` path (data-registry #229).
+- `fair pull` of a `read:` entry from a remote registry failed.
+- A DOI whose publisher refuses automated requests (e.g. Wiley, HTTP 403) was rejected as an invalid
+  identifier. An identifier that resolves is now accepted; one that does not (404) is still refused.
+- `${{DATETIME-<format>}}` always failed with "Failed to parse formatted datetime variable".
+- Substituting a path with backslashes, such as `${{CONFIG_DIR}}` on Windows, failed `fair pull` and `fair run`
+  (#267). Variables are now substituted into the configuration's values, so any text is inserted as it is.
+- `fair remote remove` crashed.
+- A ROR or GRID ID the ROR API could not parse (e.g. one containing `!`) crashed with `KeyError`
+  instead of being reported as not found.
+- Run from a subdirectory of a project, commands lost configuration changes and left a stale session
+  file, so the next command did not start the registry and `fair registry stop` needed `--force`.
+- Staging ignored the configured local registry and always used port 8000.
+- A download that failed with an HTTP error registered the error page as the data.
+- `fair run` could crash on Windows when the model printed a character the console cannot encode.
+- `fair run` in a git repository without the configured remote gave a bare `IndexError`; it now says
+  which remote is missing, or reads `run_metadata: remote_repo:` if given.
+- `fair init` in a subdirectory of a FAIR repository named it as `'True'`.
+
+## Development
+- CI ran no tests: an unused dev dependency (`pylama`) crashed `pytest --markers`, leaving the test loop
+  empty. It is removed, and a failure to list the tests now fails the job; all 8 jobs run the full suite.
+- numpy is chosen per Python version (>= 2.3 from 3.11), so Python 3.14 gets a wheel, not a source build.
+- Download tests use a local HTTP server rather than github.com.
+- `test_configuration.py::test_local_config_query` is marked `xfail`: it has never passed, and its intent
+  is unknown.
+
+# 2026-09-22 [v0.9.9](https://github.com/FAIRDataPipeline/FAIR-CLI/releases/tag/v0.9.9)
+- Requires Python >= 3.10, in step with data-registry v1.2.2.
+- `${{RUN_ID}}` in a `write:` name is left for the language API to fill in at `finalise`.
+- ROR/GRID organisation lookups failed after the ROR API moved to its v2 schema.
+
+# Between v0.2.3 and v0.9.8
+Not recorded release by release; see the [releases](https://github.com/FAIRDataPipeline/FAIR-CLI/releases)
+and the git log.
+- Fix virtual environment bug in `fair` binaries where `venv` assumes the main executable is `python`.
+- Registration of `author` and `namespace` objects.
+- Allow specification of tag to install registry from during `fair registry install`.
+- Wildcard '*' parsing introduced for data products.
+- Ability to `push` to a registry added.
+- Added `--dirty` option to `fair run` to allow running with uncommitted changes.
+- Added `config.yaml` file validation.
+- Added initialisation from existing registry.
+- Switch to setting port not local URI during initialisation.
+- Added option to specify port on `fair registry start`.
+- Added `cli-config.yaml` file validation during initialisation.
+- Added `fair reset` to list of commands.
+- Add tab completion for staging data products.
+
+# 2021-11-17 [v0.2.3](https://github.com/FAIRDataPipeline/FAIR-CLI/releases/tag/v0.2.3)
+- Move handling of the user `config.yaml` file to a separate class `JobConfiguration`.
+- Added various fixes to improve functionality within Windows.
+- Move registry installation from script execution to internal function which sets up virtual environment etc.
+- Added a test suite to the project.
+- Added additional recognised identifiers for author setup from an organisation GRID and ROR.
+
+# 2021-10-06 [v0.2.2](https://github.com/FAIRDataPipeline/FAIR-CLI/releases/tag/v0.2.2)
+- Update to package metadata for PyPi
+
+# 2021-10-06 [v0.2.1](https://github.com/FAIRDataPipeline/FAIR-CLI/releases/tag/v0.2.1)
+- Automatic starter `config.yaml` generation.
+- Local and Global CLI configurations.
+- Start/stop local registry either explicitly or during synchronisations.
+- Run logs available via git-like interface.
+- Added ability to add/remove files.
+- Repository style handling, acts like another git-like tool per project.
+- Creation of an interface for `fair` using `click`.

{fair_cli-0.9.9 → fair_cli-0.10.1}/CITATION.cff

@@ -26,7 +26,7 @@ authors:
   affiliation: University of Glasgow
   orcid: https://orcid.org/0000-0002-4424-9890
 
-date-released: 2025-04-08
+date-released: 2026-10-05
 keywords:
 - FAIR Data Pipeline
 - FAIR
@@ -36,4 +36,4 @@ license: BSD-2-Clause
 message: If you use this software, please cite it using these metadata.
 repository-code: https://github.com/FAIRDataPipeline/FAIR-CLI/
 title: "The FAIR Data Pipeline command line tool"
-version: 0.9.9
+version: 0.10.1

{fair_cli-0.9.9 → fair_cli-0.10.1}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: fair-cli
-Version: 0.9.9
+Version: 0.10.1
 Summary: Synchronization interface for the SCRC FAIR Data Pipeline registry
+Home-page: https://www.fairdatapipeline.org/
 License: BSD-2-Clause
-License-File: LICENSE
 Keywords: FAIR Data Pipeline,FAIR,Data Management,Provenance
 Author: Richard Reeve
 Author-email: richard.reeve@glasgow.ac.uk
@@ -20,8 +20,6 @@ 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: Programming Language :: Python :: 3.14
-Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Database :: Front-Ends
 Classifier: Topic :: Scientific/Engineering
 Provides-Extra: all
@@ -40,7 +38,6 @@ Requires-Dist: simplejson (>=3.17.5,<4.0.0)
 Requires-Dist: toml (>=0.10.2,<0.11.0)
 Requires-Dist: validators (>=0.18.2,<0.19.0)
 Project-URL: Documentation, https://www.fairdatapipeline.org/docs/interface/fdp/
-Project-URL: Homepage, https://www.fairdatapipeline.org/
 Project-URL: Issue Tracker, https://github.com/FAIRDataPipeline/FAIR-CLI/issues
 Project-URL: Repository, https://github.com/FAIRDataPipeline/FAIR-CLI
 Description-Content-Type: text/markdown

{fair_cli-0.9.9 → fair_cli-0.10.1}/fair/cli.py

@@ -616,9 +616,16 @@ def remote(ctx, verbose: bool = False, debug: bool = False):
 
 
 @remote.command()
-@click.argument("options", nargs=-1)
+@click.argument("options", nargs=-1, required=True)
+@click.option(
+    "--token",
+    "token_file",
+    help="File containing the API token for the remote registry",
+    prompt="Remote API Token File",
+    type=click.Path(exists=True, dir_okay=False, resolve_path=True),
+)
 @click.option("--debug/--no-debug", help="Run in debug mode", default=False)
-def add(options: typing.List[str], debug: bool) -> None:
+def add(options: typing.List[str], token_file: str, debug: bool) -> None:
     """Add a remote registry URL with option to give it a label if multiple
     remotes may be used.
 
@@ -628,13 +635,15 @@ def add(options: typing.List[str], debug: bool) -> None:
         size 1 or 2 list containing either:
             - label, url
             - url
+    token_file : str
+        file containing the API token for the remote registry
     """
     _url = options[1] if len(options) > 1 else options[0]
     _label = options[0] if len(options) > 1 else "origin"
 
     try:
         with fdp_session.FAIR(os.getcwd(), debug=debug) as fair_session:
-            fair_session.add_remote(_url, _label)
+            fair_session.add_remote(_url, token_file, _label)
     except fdp_exc.FAIRCLIException as e:
         e.err_print()
         if e.level.lower() == "error":
@@ -654,7 +663,7 @@ def remove(label: str, debug: bool) -> None:
     """
     try:
         with fdp_session.FAIR(os.getcwd(), debug=debug) as fair_session:
-            fair_session.remove_remove(label)
+            fair_session.remove_remote(label)
     except fdp_exc.FAIRCLIException as e:
         e.err_print()
         if e.level.lower() == "error":

{fair_cli-0.9.9 → fair_cli-0.10.1}/fair/common.py

@@ -19,7 +19,7 @@ Members
     FAIR_FOLDER     - name for FAIR local repository directory
 
 Functions
--------
+---------
     registry_home       - returns the location of the local data registry
     find_fair_root      - returns the closest '.fair' directory in the upper hierarchy
     find_git_root       - returns the closest '.git' directory

{fair_cli-0.9.9 → fair_cli-0.10.1}/fair/identifiers.py

@@ -192,10 +192,12 @@ def check_ror(ror: str) -> typing.Dict:
 
 def check_grid(grid_id: str) -> typing.Dict:
     """Checks if valid GRID ID using ROR (https://ror.org/) public api
+
     Parameters
     ----------
     grid_id : str
         GRID ID to be checked
+
     Returns
     -------
     typing.Dict
@@ -230,12 +232,16 @@ def _check_generic_ror(id: str) -> typing.Dict:
         logger.debug(f"{_url} Responded with {_response.status_code}")
         return _result_dict
 
-    if _response.json()["number_of_results"] == 0:
+    # A query ROR cannot parse (e.g. one containing "!") still returns 200, with
+    # "errors" in place of results
+    _items = _response.json().get("items")
+    if not _items:
+        logger.debug(f"{_url} returned no results: {_response.json().get('errors')}")
         return _result_dict
 
-    _id = _response.json()["items"][0]["id"]
+    _id = _items[0]["id"]
     # The ROR API lists every name of an organisation, marking the one to show as "ror_display"
-    _names = _response.json()["items"][0]["names"]
+    _names = _items[0]["names"]
     _name = next(
         (n["value"] for n in _names if "ror_display" in n["types"]),
         _names[0]["value"],
@@ -251,7 +257,9 @@ def _check_generic_ror(id: str) -> typing.Dict:
 def check_id_permitted(identifier: str, retries: int = 5) -> bool:
     """Check a user provided identifier is permitted
 
-    This ID is expected to be a valid URL
+    This ID is expected to be a valid URL. Permitted means that it
+    resolves: the URL, after any redirects, is served, or it redirects to a
+    page that refuses access (401/403), as a publisher behind a DOI may.
 
     Parameters
     ----------
@@ -274,9 +282,16 @@ def check_id_permitted(identifier: str, retries: int = 5) -> bool:
             headers = {}
             if fake_agent:
                 headers = {"User-Agent": str(UserAgent().chrome)}
-            requests.get(
+            _response = requests.get(
                 identifier, verify=False, allow_redirects=True, headers=headers
-            ).raise_for_status()
+            )
+            # Some publishers answer 403 to any automated request whatever
+            # the user agent, so a refusal reached through a redirect (e.g.
+            # from doi.org) still means the identifier resolved. A 404
+            # anywhere is still rejected.
+            if _response.history and _response.status_code in (401, 403):
+                return True
+            _response.raise_for_status()
             return True
         except (
             requests.exceptions.MissingSchema,

{fair_cli-0.9.9 → fair_cli-0.10.1}/fair/register.py

@@ -13,7 +13,7 @@ Contents
 ========
 
 Functions
--------
+---------
 
 """
 

{fair_cli-0.9.9 → fair_cli-0.10.1}/fair/registry/requests.py

@@ -84,6 +84,44 @@ def local_token(registry_dir: str = None) -> str:
     return _file_lines[0].strip()
 
 
+# The rest of a list, which a registry gives a page at a time, each page with
+# the address of the next. Only the cursor is taken from that address: the
+# rest of it is the registry's own idea of where it is, which behind a proxy
+# need not be where it is reached
+def _later_pages(
+    url: str, headers: typing.Dict, params: typing.Dict, page: typing.Dict
+) -> typing.List:
+    _results: typing.List = []
+    _status = 200
+
+    while page.get("next"):
+        try:
+            _next = urllib.parse.urlparse(page["next"])
+            _cursor = urllib.parse.parse_qs(_next.query)["cursor"][0]
+            _request = requests.get(
+                url, headers=headers, params={**params, "cursor": _cursor}
+            )
+            _status = _request.status_code
+            page = _request.json()
+            _results += page["results"]
+        except requests.exceptions.ConnectionError as e:
+            raise fdp_exc.UnexpectedRegistryServerState(
+                f"Failed to make registry API request '{url}'",
+                hint="Is this remote correct and the server running?",
+            ) from e
+        except (
+            json.JSONDecodeError,
+            simplejson.errors.JSONDecodeError,
+            KeyError,
+        ) as exc:
+            raise fdp_exc.RegistryAPICallError(
+                f"Failed to retrieve every page of results from '{url}'",
+                error_code=_status,
+            ) from exc
+
+    return _results
+
+
 def _access(
     uri: str,
     method: str = None,
@@ -180,6 +218,10 @@ def _access(
             f"Request failed with status code {_request.status_code}: {_info}",
             error_code=_request.status_code,
         )
+
+    if method == "get" and "results" in _json_req:
+        _result += _later_pages(_url, _headers, params, _json_req)
+
     return _result
 
 
@@ -215,8 +257,10 @@ def post(
 
     headers.update({"Content-Type": "application/json"})
 
+    # False and 0 are values, not gaps: left out, the registry would apply
+    # its own default, which for 'public' and 'primary_not_supplement' is true
     for param, value in data.copy().items():
-        if not value:
+        if not value and not isinstance(value, (bool, int, float)):
             logger.debug(
                 f"Key in post data '{param}' \
                          has no value so will be ignored"
@@ -483,7 +527,13 @@ def put_file(upload_url: str, file_loc: str) -> bool:
         bool: Will return True if the upload succeeded.
     """
     s = requests.Session()
-    _req = s.put(upload_url, data=open(file_loc, mode="rb").read())
+    # Sent from the open file, a block at a time, whatever its size. An empty
+    # file is sent as no bytes: given a file with nothing to read, requests
+    # would not state a length, which an object store insists on
+    with open(file_loc, mode="rb") as _file:
+        _req = s.put(
+            upload_url, data=_file if os.path.getsize(file_loc) else b""
+        )
     if _req.status_code not in [200, 201]:
         raise fdp_exc.RegistryError(
             f"File: {file_loc} could not be uploaded,\
@@ -492,7 +542,7 @@ def put_file(upload_url: str, file_loc: str) -> bool:
     return True
 
 
-def download_file(url: str, chunk_size: int = 8192) -> str:
+def download_file(url: str, chunk_size: int = 1024 * 1024) -> str:
     """Download a file from a given URL
 
     Parameters
@@ -500,16 +550,26 @@ def download_file(url: str, chunk_size: int = 8192) -> str:
     url : str
         address of remote file
     chunk_size : int, optional
-        chunk size for download, by default 8192
+        chunk size for download, by default 1 MiB
 
     Returns
     -------
     str
         path of downloaded temporary file
+
+    Raises
+    ------
+    requests.HTTPError
+        if the server answers with an error status
+    fdp_exc.FAIRCLIException
+        if the file could not be fetched, or not all of it
     """
     # Save the data to a temporary file so we can calculate the hash
     _file = tempfile.NamedTemporaryFile(delete=False)
     _fname = _file.name
+    # Only the name is wanted: the file is written, and on failure removed,
+    # by name, which Windows refuses while this handle is open
+    _file.close()
 
     # Copy File if local
     if "file://" in url:
@@ -517,6 +577,7 @@ def download_file(url: str, chunk_size: int = 8192) -> str:
         try:
             shutil.copy2(_local_fname, _fname)
         except Exception as e:
+            os.remove(_fname)
             raise fdp_exc.FAIRCLIException(
                 f"Failed to download file '{url}'"
                 f" due to connection error: {traceback.format_exc()}"
@@ -526,14 +587,37 @@ def download_file(url: str, chunk_size: int = 8192) -> str:
             requests.packages.urllib3.disable_warnings(category=InsecureRequestWarning)
             headers = {"User-Agent": str(UserAgent().chrome)}
             response = requests.get(
-                url, allow_redirects=True, verify=False, headers=headers
+                url,
+                allow_redirects=True,
+                verify=False,
+                headers=headers,
+                stream=True,
             )
-            open(_fname, mode="wb").write(response.content)
         except Exception as e:
+            os.remove(_fname)
             raise fdp_exc.FAIRCLIException(
                 f"Failed to download file '{url}'"
                 f" due to connection error: {traceback.format_exc()}"
             ) from e
+        # Outside the try, so that callers can tell an HTTP error from a
+        # failure to connect, and an error page is never saved as the data
+        try:
+            response.raise_for_status()
+            # Written as it arrives, a block at a time, whatever its size
+            with open(_fname, mode="wb") as _out:
+                for _chunk in response.iter_content(chunk_size=chunk_size):
+                    _out.write(_chunk)
+        except requests.HTTPError:
+            os.remove(_fname)
+            raise
+        except requests.RequestException as e:
+            os.remove(_fname)
+            raise fdp_exc.FAIRCLIException(
+                f"Failed to download all of file '{url}'"
+                f" due to connection error: {traceback.format_exc()}"
+            ) from e
+        finally:
+            response.close()
 
     return _fname
 

{fair_cli-0.9.9 → fair_cli-0.10.1}/fair/registry/storage.py

@@ -473,6 +473,13 @@ def store_data_file(
         registry_uri=uri,
         registry_token=token,
         data_product_url=_data_prod_url,
+        original_store_url=_get_url_from_original_store(
+            data=data,
+            registry_uri=uri,
+            registry_token=token,
+            storage_loc_url=_post_store_loc,
+            is_public=public,
+        ),
     )
 
 
@@ -493,7 +500,12 @@ def _get_url_from_storage_loc(
         "hash": _hash,
     }
 
-    _search_data = {"hash": _hash}
+    # The same file may be recorded under another root as well, as where an
+    # external object was fetched from
+    _search_data = {
+        "hash": _hash,
+        "storage_root": fdp_req.get_obj_id_from_url(root_store_url),
+    }
 
     return fdp_req.post_else_get(
         registry_uri,
@@ -504,6 +516,73 @@ def _get_url_from_storage_loc(
     )
 
 
+# The storage location of the place an external object's file was fetched
+# from: the 'root' and 'path' of its 'register' entry, with the hash its
+# location in the data store was given. None if the entry names no place
+# that anyone else could fetch it from: a file on this machine, or (a root
+# that is a bare path) one beside the registry itself.
+def _get_url_from_original_store(
+    data: typing.Dict,
+    registry_uri: str,
+    registry_token: str,
+    storage_loc_url: str,
+    is_public: bool,
+) -> typing.Optional[str]:
+    _root = data.get("root")
+    _path = data.get("path")
+
+    if not _root or not _path or _root.startswith(("/", "file://")):
+        return None
+
+    _root_url = fdp_req.post_else_get(
+        registry_uri,
+        "storage_root",
+        registry_token,
+        data={"root": _root, "local": False},
+        params={"root": _root},
+    )
+    _hash = fdp_req.url_get(storage_loc_url, registry_token)["hash"]
+
+    # A registry records a file once under a root, whatever its path there
+    _recorded = [
+        location
+        for location in fdp_req.get(
+            registry_uri,
+            "storage_location",
+            registry_token,
+            params={
+                "hash": _hash,
+                "storage_root": fdp_req.get_obj_id_from_url(_root_url),
+            },
+        )
+        if str(location["public"]).lower() == str(is_public).lower()
+    ]
+
+    if _recorded:
+        if _recorded[0]["path"] != _path:
+            logger.warning(
+                "The file at '%s%s' is already recorded at '%s%s', "
+                "which is given as where it came from",
+                _root,
+                _path,
+                _root,
+                _recorded[0]["path"],
+            )
+        return _recorded[0]["url"]
+
+    return fdp_req.post(
+        registry_uri,
+        "storage_location",
+        registry_token,
+        data={
+            "path": _path,
+            "storage_root": _root_url,
+            "public": str(is_public).lower(),
+            "hash": _hash,
+        },
+    )["url"]
+
+
 def _get_url_from_file_type(
     data: typing.Dict, local_file: str, registry_uri: str, registry_token: str
 ) -> str:
@@ -539,6 +618,7 @@ def _get_url_from_external_obj(
     registry_uri: str,
     registry_token: str,
     data_product_url: str,
+    original_store_url: str = None,
 ) -> typing.Dict:
     _expected_ext_obj_keys = ("release_date", "primary", "title")
 
@@ -553,6 +633,7 @@ def _get_url_from_external_obj(
         "title": data["title"],
         "primary_not_supplement": f'{data["primary"]}',
         "release_date": data["release_date"],
+        "original_store": original_store_url,
     }
     _external_obj_data.update(_get_identifier_from_data(data, local_file))
 
@@ -672,10 +753,10 @@ def _get_identifier_from_data(data: typing.Dict, label: str) -> typing.Dict[str,
             raise fdp_exc.UserConfigError(
                 f"No identifier/alternate_identifier given for item '{label}'",
                 hint="You must provide either a URL 'identifier', or "
-                "'unique_name' and 'source_name' keys",
+                "'unique_name' and 'alternate_identifier_type' keys",
             ) from e
 
-        _identifier["alternate_identifier"] = data.get(
+        _identifier["alternate_identifier_type"] = data.get(
             "alternate_identifier_type", "local source descriptor"
         )
 
@@ -868,6 +949,14 @@ def upload_remote_file(
     """
     if not os.path.exists(file_loc):
         raise fdp_exc.FileNotFoundError(f"File: {file_loc} does not exist")
-    _upload_url = get_upload_url(file_loc, remote_uri, remote_token)
+    try:
+        _upload_url = get_upload_url(file_loc, remote_uri, remote_token)
+    except fdp_exc.RegistryAPICallError as e:
+        # A registry refuses an address to upload a file it already holds,
+        # found by its hash: there is then nothing to send
+        if e.error_code != 409:
+            raise
+        logger.debug(f"File {file_loc} is already in the registry's store")
+        return
     logger.debug(f"Uploading {file_loc} to URL: {_upload_url}")
     fdp_req.put_file(_upload_url, file_loc)