fair-cli 0.9.4__tar.gz → 0.9.6__tar.gz

{fair_cli-0.9.4 → fair_cli-0.9.6}/CITATION.cff

@@ -26,7 +26,7 @@ authors:
   affiliation: University of Glasgow
   orcid: https://orcid.org/0000-0002-4424-9890
 
-date-released: 2023-09-07
+date-released: 2024-08-04
 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.4
+version: 0.9.6

{fair_cli-0.9.4 → fair_cli-0.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fair-cli
-Version: 0.9.4
+Version: 0.9.6
 Summary: Synchronization interface for the SCRC FAIR Data Pipeline registry
 Home-page: https://www.fairdatapipeline.org/
 License: BSD-2-Clause
@@ -30,7 +30,7 @@ Requires-Dist: PyYAML (>=5.4.1,<7.0.0)
 Requires-Dist: click (>=8.0.0,<9.0.0)
 Requires-Dist: email-validator (>=1.1.3,<2.0.0)
 Requires-Dist: fake-useragent (>=1,<2)
-Requires-Dist: pre-commit (>=2.15.0,<3.0.0)
+Requires-Dist: pre-commit (>=3,<4)
 Requires-Dist: pydantic[email] (>=1.9.0,<2.0.0)
 Requires-Dist: requests (>=2.23.0,<3.0.0)
 Requires-Dist: rich (>=10.2.3,<12.0.0)

{fair_cli-0.9.4 → fair_cli-0.9.6}/fair/configuration/__init__.py

@@ -379,22 +379,22 @@ def get_current_user_uri(repo_loc: str) -> str:
         raise fdp_exc.CLIConfigurationError("No user URI identifier defined.")
     return _uri
 
-def get_current_user_github(repo_loc: str) -> str:
+def get_current_user_remote_user(repo_loc: str) -> str:
     """Retrieves the URI identifier for the current user
 
     Returns
     -------
     str
-        github username
+        remote username
     """
     _local_conf = read_local_fdpconfig(repo_loc)
     try:
-        _github = _local_conf["user"]["github"]
+        _remote_user = _local_conf["user"]["remote_user"]
     except KeyError:
-        _github = None
-    if not _github or _github == "None":
-        raise fdp_exc.CLIConfigurationError("No user GitHub username defined.")
-    return _github
+        _remote_user = None
+    if not _remote_user or _remote_user == "None":
+        raise fdp_exc.CLIConfigurationError("No remote user defined.")
+    return _remote_user
 
 def check_registry_exists(registry: str = None) -> typing.Optional[str]:
     """Checks if fair registry is set up on users machine
@@ -580,6 +580,18 @@ def _handle_github(user_github: str) -> typing.Tuple[typing.Dict, str]:
     click.echo(f"Found entry: {_user_info['github']} ")
     return _user_info, _def_ospace
 
+def _handle_gitlab(user_gitlab, gitlab_url = "https://gitlab.com") -> typing.Tuple[typing.Dict, str]:
+    _user_info = fdp_id.check_gitlab(user_gitlab.strip(), gitlab_url.strip())
+    while not _user_info:
+        time.sleep(3)
+        click.echo(f"Invalid GitLab Username '{user_gitlab}' given.")
+        user_gitlab = click.prompt("GitLab Username")
+        _user_info = fdp_id.check_gitlab(user_gitlab.strip())
+
+    _def_ospace = _user_info["gitlab"].lower()
+    
+    click.echo(f"Found entry: {_user_info['gitlab']} ")
+    return _user_info, _def_ospace
 
 
 def _handle_uuid() -> typing.Tuple[typing.Dict, str]:
@@ -608,14 +620,19 @@ def _handle_uuid() -> typing.Tuple[typing.Dict, str]:
     return _user_info, _def_ospace
 
 
-def _get_user_info_and_namespaces(local: bool = False) -> typing.Dict[str, typing.Dict]:
+def _get_user_info_and_namespaces(local: bool = False, remote_url: str = None) -> typing.Dict[str, typing.Dict]:
     _user_email = click.prompt("Email (optional)", default = "")
 
     _invalid_input = True
+    if not local:
+        _remote_auth_provider = fdp_req.get_auth_provider(remote_url)
+        _remote_auth_url = fdp_req.get_auth_url(remote_url)
+    else:
+        _remote_auth_url = None
 
     while _invalid_input:
         _id_type = click.prompt(
-            "User ID system (GITHUB/ORCID/ROR/GRID/None)", default="GITHUB"
+            "User ID system (GITHUB/GITLAB/ORCID/ROR/GRID/None)", default="GITHUB"
         )
         if _id_type.upper() == "GITHUB":
             _user_github = click.prompt("GitHub Username")
@@ -625,6 +642,18 @@ def _get_user_info_and_namespaces(local: bool = False) -> typing.Dict[str, typin
                 _user_info["family_name"] = click.prompt("Family Name")
                 _user_info["name"] = " ".join([_user_info["given_names"], _user_info["family_name"]])
             _invalid_input = False
+        elif _id_type.upper() == "GITLAB":
+            if not _remote_auth_url:
+                _remote_auth_url = click.prompt(
+                "GitLab URL", default="https://gitlab.com/"
+            )
+            _user_gitlab = click.prompt("GitLab Username")
+            _user_info, _def_ospace = _handle_gitlab(_user_gitlab, _remote_auth_url)
+            if not _user_info["name"]:
+                _user_info["given_names"] = click.prompt("Given Names")
+                _user_info["family_name"] = click.prompt("Family Name")
+                _user_info["name"] = " ".join([_user_info["given_names"], _user_info["family_name"]])
+            _invalid_input = False
         elif _id_type.upper() == "ORCID":
             _user_orcid = click.prompt("ORCID")
             _user_info, _def_ospace = _handle_orcid(_user_orcid)
@@ -651,18 +680,34 @@ def _get_user_info_and_namespaces(local: bool = False) -> typing.Dict[str, typin
 
     _namespaces = {"input": _def_ispace, "output": _def_ospace}
 
-    if not "github" in _user_info:
-        if local:
-            _user_info["github"] = "FAIRDataPipeline"
-        else:
-            _user_github = click.prompt("GitHub Username")
-            _user_github_info = _handle_github(_user_github)[0]
-            _user_info["github"] = _user_github_info["github"]
+    if not local:
+        if _remote_auth_provider == "GitHub":
+            if not "github" in _user_info:
+                _user_github = click.prompt("GitHub Username")
+                _user_github_info = _handle_github(_user_github)[0]
+                _user_info["remote_user"] = _user_github_info["github"]
+            else:
+                _user_info["remote_user"] = _user_info["github"]
+        elif _remote_auth_provider == "GitLab":
+            if not "gitlab" in _user_info:
+                _user_gitlab = click.prompt("GitLab Username")
+                _user_gitlab_info = _handle_gitlab(_user_gitlab, _remote_auth_url)[0]
+                _user_info["remote_user"] = _user_gitlab_info["gitlab"]
+            else:
+                _user_info["remote_user"] = _user_info["gitlab"]
+    else:
+        _user_info["remote_user"] = "FAIRDataPipeline"
+
+    # Unset unused variables
+    _user_info.pop('github', None)
+    _user_info.pop('gitlab', None)
 
     if not _user_email:
-        _user_info["email"] = f'{_user_info["github"]}@users.noreply.github.com'
+        _user_info["email"] = f'{_user_info["remote_user"]}@users.noreply.github.com'
     else:
         _user_info["email"] = _user_email
+    
+    logger.debug(f'{_user_info}')
 
     return {"user": _user_info, "namespaces": _namespaces}
 
@@ -741,7 +786,7 @@ def global_config_query(
 
     if not fdp_serv.check_server_running():
         if _ := click.confirm(
-            "Local registry is offline, would you like to start it?",
+            "Local registry is offline, would you like to start it and for it to remain running?",
             default=False,
         ):
             fdp_serv.launch_server(registry_dir=registry)
@@ -768,7 +813,7 @@ def global_config_query(
     if _loc_data_store[-1] != os.path.sep:
         _loc_data_store += os.path.sep
 
-    _glob_conf_dict = _get_user_info_and_namespaces(local)
+    _glob_conf_dict = _get_user_info_and_namespaces(local, _remote_url)
     _glob_conf_dict["registries"] = {
         "local": {
             "uri": _local_uri,

{fair_cli-0.9.4 → fair_cli-0.9.6}/fair/configuration/validation.py

@@ -108,8 +108,8 @@ class User(pydantic.BaseModel):
     name: typing.Optional[str] = pydantic.Field(
         None, title="Full Name", description="Full name for the user"
     )
-    github: typing.Optional[str] = pydantic.Field(
-        None, title="GitHub Username", description="GitHub Username for the user"
+    remote_user: typing.Optional[str] = pydantic.Field(
+        None, title="Remote Username", description="Remote Username for the user"
     )
 
     class Config:

{fair_cli-0.9.4 → fair_cli-0.9.6}/fair/identifiers.py

@@ -82,7 +82,7 @@ def check_orcid(orcid: str) -> typing.Dict:
     return _result_dict
 
 def check_github(github: str) -> typing.Dict:
-    """Checks if valid ORCID using ORCID public api
+    """Checks if valid GitHub Username using GitHub Username public api
 
     Parameters
     ----------
@@ -122,6 +122,43 @@ def check_github(github: str) -> typing.Dict:
 
     return _result_dict
 
+def check_gitlab(gitlab: str, gitlab_url:str = "https://gitlab.com/") -> typing.Dict:
+    """Checks if valid GitLab Username using Gitlab profile address
+
+    Parameters
+    ----------
+    gitlab : str
+        gitlab username to be checked
+    gitlab_url: str
+        URL of the gitlab instance, defaults to "https://gitlab.com/"
+
+    Returns
+    -------
+    typing.Dict
+        metadata from the given ID
+    """
+    _url = urllib.parse.urljoin(gitlab_url, gitlab)
+    requests.packages.urllib3.disable_warnings(category=InsecureRequestWarning)
+    _response = requests.get(_url, verify = False, allow_redirects = True)
+
+    _result_dict: typing.Dict[str, typing.Any] = {}
+
+    if _response.status_code == 403:
+        time.sleep(3)
+        _header = {"Accept": "application/json", 'User-Agent':str(UserAgent().chrome)}
+        _response = requests.get(_url, headers=_header, verify = False, allow_redirects = True)
+
+    if _response.status_code != 200:
+        logger.debug(f"{_url} Responded with {_response.status_code}")
+        return _result_dict
+    
+    _username = _response.url.rsplit('/', 1)[-1]
+
+    _result_dict["name"] = None   
+    _result_dict["gitlab"] = _username
+    _result_dict["uri"] = _response.url
+
+    return _result_dict
 
 def check_ror(ror: str) -> typing.Dict:
     """Checks if valid ROR using ROR public api

{fair_cli-0.9.4 → fair_cli-0.9.6}/fair/registry/requests.py

@@ -629,7 +629,25 @@ def get_obj_type_from_url(request_url: str, token: str) -> str:
     return ""
 
 
-def get_author_exists(registry_uri, token = None, name = None, identifier = None):
+def get_author_exists(registry_uri, token = None, name = None, identifier = None) -> str:
+    """Get an author given an name and or identifier
+
+    Parameters
+    ----------
+    registry_url : str
+        Url of the registry to check for the author
+    token : str (optional)
+        token for the given registry
+    name : str (optional)
+        name to be checked
+    identifier : str (optional)
+        identifier to be checker
+    
+    Returns
+    -------
+    str
+        The url of the author if they exist else None 
+    """
     if not name and not identifier:
         return {}
     if not token:
@@ -647,4 +665,50 @@ def get_author_exists(registry_uri, token = None, name = None, identifier = None
     )
     if _author_exists:
         return _author_exists[0]["url"]
-    return {}
+    return {}
+
+def get_auth_provider(registry_uri: str, token: str = None) -> str:
+    """Retrived the auth provider from the remote registry
+
+    Parameters
+    ----------
+    registry_url : str
+        url of the remote registry
+    token : str (optional)
+        remote registry token
+    
+    Returns
+    -------
+    str
+        The remote authentication provider
+    """
+    _url = urllib.parse.urljoin(registry_uri, "auth-provider")
+    _response = url_get(_url, token)
+    if not _response["auth_provider"]:
+        raise fdp_exc.RegistryError(f'The remote registry {registry_uri} \
+                                    did not provide an authentication provider \
+                                    is the remote registry correcly configured?')
+    return _response["auth_provider"]
+
+def get_auth_url(registry_uri: str, token: str = None) -> str:
+    """Retrived the auth url from the remote registry
+
+    Parameters
+    ----------
+    registry_url : str
+        url of the remote registry
+    token : str (optional)
+        remote registry token
+    
+    Returns
+    -------
+    str
+        The remote authentication url
+    """
+    _url = urllib.parse.urljoin(registry_uri, "auth-url")
+    _response = url_get(_url, token)
+    if not _response["auth_url"]:
+        raise fdp_exc.RegistryError(f'The remote registry {registry_uri} \
+                                    did not provide an authentication provider \
+                                    is the remote registry correcly configured?')
+    return _response["auth_url"]

{fair_cli-0.9.4 → fair_cli-0.9.6}/fair/registry/server.py

@@ -387,13 +387,13 @@ def install_registry(
         stdout=subprocess.DEVNULL if silent else None,
     )
 
-    subprocess.check_call(
-        [_venv_python, "-m", "pip", "install", "whitenoise"],
-        shell=False,
-        stdout=subprocess.DEVNULL if silent else None,
-    )
+    # subprocess.check_call(
+    #     [_venv_python, "-m", "pip", "install", "whitenoise"],
+    #     shell=False,
+    #     stdout=subprocess.DEVNULL if silent else None,
+    # )
 
-    _requirements = os.path.join(install_dir, "local-requirements.txt")
+    _requirements = os.path.join(install_dir, "requirements.txt")
 
     if not os.path.exists(_requirements):
         raise FileNotFoundError(f"Expected file '{_requirements}'")

{fair_cli-0.9.4 → fair_cli-0.9.6}/fair/registry/sync.py

@@ -146,8 +146,7 @@ def sync_dependency_chain(
     dest_token: str,
     origin_token: str,
     local_data_store: str = None,
-    public: bool = False,
-    remote_author_url = None
+    public: bool = False
 ) -> typing.Dict[str, str]:
     """Push an object and all of its dependencies to the remote registry
 
@@ -187,7 +186,7 @@ def sync_dependency_chain(
     )
 
     _new_urls: typing.Dict[str, str] = {k: "" for k in _dependency_chain}
-    _writable_fields: typing.Dict[str, str] = {}
+    _writable_fields: typing.Dict[str, str] = {}    
 
     # For every object (and the order) in the dependency chain
     # post the object then store the URL so it can be used to assemble those
@@ -224,9 +223,9 @@ def sync_dependency_chain(
             object_url=object_url,
             new_urls=_new_urls,
             writable_data=_writable_data,
+            object_data = _obj_data,
             local_data_store = local_data_store,
-            public = public,
-            remote_author_url = remote_author_url
+            public = public
         )
 
         if not fdp_util.is_api_url(dest_uri, _new_url):
@@ -248,9 +247,9 @@ def _get_new_url(
     object_url: str,
     new_urls: typing.Dict,
     writable_data: typing.Dict,
+    object_data = {},
     local_data_store = None,
-    public = False,
-    remote_author_url = None
+    public = False
 ) -> typing.Tuple[typing.Dict, typing.List]:
     """Internal Function to return a resgistry entry from the remote registry given an origin entry URL
     If the entry does not exist it will be created
@@ -303,6 +302,7 @@ def _get_new_url(
     # (as remote URL will never match local)
 
     _obj_type = fdp_req.get_obj_type_from_url(object_url, token=origin_token)
+    _obj_id = fdp_req.get_obj_id_from_url(object_url)
 
     _filters = {
         k: v
@@ -317,21 +317,28 @@ def _get_new_url(
     if dest_uri == origin_uri:
         raise fdp_exc.InternalError("Cannot push object to its source address")
 
-     # If public replace storage root, path
+    # If Public is true then any files will be uploaded to the remote registry
+    # If local_data_store is set we're pulling to a local registry
     if public and not local_data_store:
+        # The remote data_store storage_root URL should always be the 1st storage_root
         _remote_storage_root_url = urllib.parse.urljoin(dest_uri, "storage_root/1/")
-        if _obj_type == "storage_root":
+        # If the current objects a storage_root and the root is the first (data_store)
+        # then simply return the remote
+        if _obj_type == "storage_root" and _obj_id == '1':
             return _remote_storage_root_url
-        if "path" in _new_obj_data:
-            _new_obj_data["path"] = _filters["path"] = _new_obj_data["hash"]
-        if "storage_root" in _new_obj_data:
-            _new_obj_data["storage_root"] = _remote_storage_root_url
-            _filters["storage_root"] = fdp_req.get_obj_id_from_url(_remote_storage_root_url)
-
-    # if remote_author_url and _obj_type == "object":
-    #     _new_obj_data["authors"] = _filters["authors"] = [remote_author_url]
+        # If the current object is a storage_location
+        elif _obj_type == "storage_location":
+            # Again if the storage_root is the data_store (storage_root 1)
+            if fdp_req.get_obj_id_from_url(object_data.get("storage_root", "/2")) == '1':
+                # Update the new object path and filter path
+                _new_obj_data["path"] = _filters["path"] = _new_obj_data["hash"]
+                # Update the new object storage_root
+                _new_obj_data["storage_root"] = _remote_storage_root_url
+                # Update the filters for storage_root to the ID
+                _filters["storage_root"] = fdp_req.get_obj_id_from_url(_remote_storage_root_url)
 
     if _obj_type == "object":
+        _new_obj_data["authors"] = []
         _new_author_urls = []
         _filters["authors"] = []
         _tmp_obj = fdp_req.url_get(object_url, origin_token)
@@ -402,16 +409,16 @@ def sync_user_author(
     dest_token: str,
     origin_token: str,
     author_url: str,
-    github: str
+    remote_user: str
 ) -> None:
     current_user = fdp_req.get(
         dest_uri,
         "users",
         dest_token,
-        params= {"username": github}
+        params= {"username": remote_user}
     )
     if not current_user:
-        raise fdp_exc.RegistryError(f"No user matching {github}, on remote registry", "Does your GitHub username match the remote registry GitHub user?")
+        raise fdp_exc.RegistryError(f"No user matching {remote_user}, on remote registry", "Does your Remote username match the remote registry user?")
     current_user_url = current_user[0]['url']
     fdp_store.store_user_author(dest_uri, dest_token, current_user_url, author_url)
 
@@ -432,13 +439,13 @@ def get_new_author_url(
             if k in _writable_fields
         }
     return _get_new_url(
-        origin_uri,
-        origin_token,
-        dest_uri,
-        dest_token,
-        author_url,
-        {},
-        _writable_data
+        origin_uri= origin_uri,
+        origin_token= origin_token,
+        dest_uri= dest_uri,
+        dest_token= dest_token,
+        object_url= author_url,
+        new_urls= {},
+        writable_data= _writable_data
     )
 
 def sync_data_products(
@@ -449,8 +456,7 @@ def sync_data_products(
     remote_label: str,
     data_products: typing.List[str],
     local_data_store: str = None,
-    force: bool = False,
-    remote_author_url = None
+    force: bool = False
 ) -> None:
     """Transfer data products from one registry to another
 
@@ -544,8 +550,7 @@ def sync_data_products(
             dest_token=dest_token,
             origin_token=origin_token,
             local_data_store=local_data_store,
-            public=_is_public,
-            remote_author_url = remote_author_url
+            public=_is_public
         )
         # If local_data_store assume we're syncing from remote to local
         if local_data_store:
@@ -567,8 +572,8 @@ def sync_data_products(
                 for origin_input_code_run in origin_input_code_runs:
                     dest_component_url = get_dest_component_url(origin_component_url, dest_uri, dest_token, origin_token)
                     dest_inputs = [dest_component_url]
-                    dest_inputs += get_dest_inputs(origin_input_code_run["inputs"], origin_uri, dest_uri, dest_token, origin_token, remote_label, remote_author_url)
-                    sync_code_run(origin_uri, dest_uri, dest_token, origin_token, origin_input_code_run["uuid"], inputs= dest_inputs, remote_author_url = remote_author_url)
+                    dest_inputs += get_dest_inputs(origin_input_code_run["inputs"], origin_uri, dest_uri, dest_token, origin_token, remote_label)
+                    sync_code_run(origin_uri, dest_uri, dest_token, origin_token, origin_input_code_run["uuid"], inputs= dest_inputs)
                 
                 origin_output_code_runs = fdp_req.get(
                         origin_uri,
@@ -578,9 +583,10 @@ def sync_data_products(
                     )
                 for origin_output_code_run in origin_output_code_runs:
                     dest_component_url = get_dest_component_url(origin_component_url, dest_uri, dest_token, origin_token)
-                    dest_inputs = get_dest_inputs(origin_output_code_run["inputs"], origin_uri, dest_uri, dest_token, origin_token, remote_label, force, remote_author_url)
-                    sync_code_run(origin_uri, dest_uri, dest_token, origin_token, origin_output_code_run["uuid"], inputs= dest_inputs, outputs= [dest_component_url], remote_author_url = remote_author_url)
+                    dest_inputs = get_dest_inputs(origin_output_code_run["inputs"], origin_uri, dest_uri, dest_token, origin_token, remote_label, force)
+                    sync_code_run(origin_uri, dest_uri, dest_token, origin_token, origin_output_code_run["uuid"], inputs= dest_inputs, outputs= [dest_component_url])
         logger.info(f"Synced Data Product: {data_product}")
+
 def get_dest_component_url(
     origin_component_url: str,
     dest_uri: str,
@@ -625,8 +631,7 @@ def sync_code_runs(
     remote_label: str,
     code_runs: typing.List[str],
     local_data_store: str = None,
-    force: bool = False,
-    remote_author_url = None
+    force: bool = False
 ) -> None:
     """Transfer data code_run(s) from one registry to another
 
@@ -695,8 +700,7 @@ def sync_code_runs(
             remote_label, 
             _origin_data_products_formatted, 
             local_data_store,
-            force,
-            remote_author_url)
+            force)
 
         # Iterate through formatted objects and get their new values from the remote registry
         for _origin_data_product_formatted in _origin_data_products_formatted:
@@ -724,7 +728,7 @@ def sync_code_runs(
             if _origin_data_product_formatted in _outputs_data_products:
                 _dest_outputs += _dest_object["components"]
         logger.debug(f'attempting to sync coderun {code_run_uuid} with inputs {_dest_inputs} and outputs {_dest_outputs}')
-        sync_code_run(origin_uri, dest_uri, dest_token, origin_token, code_run_uuid, _dest_inputs, _dest_outputs, remote_author_url = remote_author_url)
+        sync_code_run(origin_uri, dest_uri, dest_token, origin_token, code_run_uuid, _dest_inputs, _dest_outputs)
         logger.info(f"Synced Code Run: {code_run_uuid}")
 
 # Internal function to return the (remote) object associated with a code_run field containing and object url
@@ -771,8 +775,7 @@ def sync_code_run(
     origin_token: str,
     code_run_uuid: str,
     inputs = [],
-    outputs = [],
-    remote_author_url = None) -> typing.Dict:
+    outputs = []) -> typing.Dict:
     """_summary_
 
     Args:
@@ -819,8 +822,7 @@ def sync_code_run(
         origin_uri=origin_uri,
         dest_token=dest_token,
         origin_token=origin_token,
-        public= True,
-        remote_author_url = remote_author_url
+        public= True
         )
         _dest_code_run_model_config = get_dest_object_url(code_run["model_config"], dest_uri, dest_token, origin_token)
         upload_object(origin_uri, dest_uri, dest_token, origin_token, code_run["model_config"])
@@ -833,8 +835,7 @@ def sync_code_run(
             origin_uri=origin_uri,
             dest_token=dest_token,
             origin_token=origin_token,
-            public= True,
-            remote_author_url = remote_author_url
+            public= True
             )
             _dest_code_run_code_repo = get_dest_object_url(code_run["code_repo"],  dest_uri, dest_token, origin_token)
         # Sync Submision Script
@@ -844,8 +845,7 @@ def sync_code_run(
         origin_uri=origin_uri,
         dest_token=dest_token,
         origin_token=origin_token,
-        public= True,
-        remote_author_url = remote_author_url
+        public= True
         )
         _dest_code_run_submission_script = get_dest_object_url(code_run["submission_script"], dest_uri, dest_token, origin_token)
         upload_object(origin_uri, dest_uri, dest_token, origin_token, code_run["submission_script"])
@@ -940,8 +940,7 @@ def get_dest_inputs(origin_inputs: typing.List,
     dest_token: str,
     origin_token: str,
     remote_label: str,
-    force: bool = False,
-    remote_author_url = None) -> list:
+    force: bool = False) -> list:
     """Returns a list of input component urls on the destination registry
      from a given list of input component urls from the origin registry
      assumes the destination componets already exists in the remote registry
@@ -962,7 +961,7 @@ def get_dest_inputs(origin_inputs: typing.List,
     for origin_input in origin_inputs:
         component_data_products = get_data_products_from_component(origin_input, origin_token)
         if component_data_products:
-            sync_data_products(origin_uri, dest_uri, dest_token, origin_token, remote_label, format_data_product_list(component_data_products, origin_token), force= force, remote_author_url = remote_author_url)
+            sync_data_products(origin_uri, dest_uri, dest_token, origin_token, remote_label, format_data_product_list(component_data_products, origin_token), force= force)
             for data_product_url in component_data_products:
                 origin_data_product_object_url = fdp_req.url_get(data_product_url, origin_token)["object"]
                 dest_object_url = get_dest_object_url(origin_data_product_object_url, dest_uri, dest_token, origin_token)
@@ -975,8 +974,7 @@ def get_dest_inputs(origin_inputs: typing.List,
                 origin_uri=origin_uri,
                 dest_token=dest_token,
                 origin_token=origin_token,
-                public= is_component_public(origin_input, origin_token),
-                remote_author_url = remote_author_url
+                public= is_component_public(origin_input, origin_token)
                 )
             dest_inputs.append(get_dest_component_url(origin_input, dest_uri, dest_token, origin_token))
     return dest_inputs

{fair_cli-0.9.4 → fair_cli-0.9.6}/fair/session.py

@@ -400,7 +400,7 @@ class FAIR:
             ),
             origin_token=fdp_req.local_token(),
             author_url = remote_author_url,
-            github = fdp_conf.get_current_user_github(self._session_loc)
+            remote_user = fdp_conf.get_current_user_remote_user(self._session_loc)
         )
 
         fdp_sync.sync_code_runs(
@@ -411,8 +411,7 @@ class FAIR:
             ),
             origin_token=fdp_req.local_token(),
             remote_label=remote,
-            code_runs=_staged_code_runs,
-            remote_author_url = remote_author_url
+            code_runs=_staged_code_runs
         )
 
         fdp_sync.sync_data_products(
@@ -423,8 +422,7 @@ class FAIR:
             ),
             origin_token=fdp_req.local_token(),
             remote_label=remote,
-            data_products=_staged_data_products,
-            remote_author_url = remote_author_url
+            data_products=_staged_data_products
         )
 
         self._session_config.write_log_lines(
@@ -495,7 +493,7 @@ class FAIR:
 
         self._logger.debug("Pulling data products locally")
 
-        # Only push data products if there are any to do so, this covers the
+        # Only pull data products if there are any to do so, this covers the
         # case whereby no remote has been setup and we just want to register
         # items on the local registry
         if _readables:
@@ -1329,7 +1327,7 @@ class FAIR:
                     "Expected key 'directory' for local registry in CLI configuration"
                 )
 
-        _user_keys = ["email", "family_name", "given_names", "uuid", "github"]
+        _user_keys = ["email", "family_name", "given_names", "uuid", "remote_user"]
 
         for key in _user_keys:
             if key not in cli_config["user"]:
@@ -1338,7 +1336,7 @@ class FAIR:
                     f"Expected key 'user:{key}' in CLI configuration file"
                 )
 
-        if not cli_config["user"]["github"] and not cli_config["user"]["uuid"]:
+        if not cli_config["user"]["remote_user"] and not cli_config["user"]["uuid"]:
             raise fdp_exc.CLIConfigurationError(
                 "At least one of 'user:github' and 'user:uuid' must be provided "
                 " in CLI configuration"

{fair_cli-0.9.4 → fair_cli-0.9.6}/fair/testing.py

@@ -82,7 +82,7 @@ def create_configurations(
             "orcid": "000-0000-0000-0000",
             "uri": f'{fdp_id.ID_URIS["github"]}FAIRDataPipeline',
             "uuid": "2ddb2358-84bf-43ff-b2aa-3ac7dc3b49f1",
-            "github": "FAIRDataPipeline"
+            "remote_user": "FAIRDataPipeline"
         },
         "git": {
             "local_repo": local_git_dir,

{fair_cli-0.9.4 → fair_cli-0.9.6}/pyproject.toml

@@ -10,7 +10,6 @@ authors = [
 classifiers = [
   "License :: OSI Approved :: BSD License",
   "Intended Audience :: Science/Research",
-  "Programming Language :: Python :: 3.8",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
@@ -25,7 +24,7 @@ classifiers = [
 ]
 description = "Synchronization interface for the SCRC FAIR Data Pipeline registry"
 name = "fair-cli"
-version = "0.9.4"
+version = "0.9.6"
 
 homepage = "https://www.fairdatapipeline.org/"
 
@@ -55,7 +54,7 @@ Jinja2 = "^3.0.1"
 PyYAML = ">=5.4.1,<7.0.0"
 click = "^8.0.0"
 email-validator = "^1.1.3"
-pre-commit = "^2.15.0"
+pre-commit = "^3"
 pydantic = {extras = ["email"], version = "^1.9.0"}
 python = "^3.8.0,<4.0"
 requests = "^2.23.0"
@@ -69,26 +68,26 @@ fake-useragent = "^1"
 [tool.poetry.dev-dependencies]
 bandit = "*"
 black = "*"
-coverage = "7.2.*"
-deepdiff = "^5.5.0"
+coverage = "*"
+deepdiff = "^7"
 flake8 = "*"
 isort = "^5.10.1"
 mypy = "^0.931"
 poetry = "^1.1.12"
-pre-commit = "^2.17.0"
+pre-commit = "^3"
 pycodestyle = "^2.7.0"
 pydocstyle = "^6.0.0"
-pylama = "^7.7.1"
+pylama = "^8"
 pytest = "*"
+pytest-shutil = "*"
 pytest-cov = "*"
 pytest-dependency = "*"
 pytest-mock = "*"
-pytest-virtualenv = "*"
 requests-mock = "*"
 boto3 = "^1.24"
-moto = "^4.0.3"
-Flask = "^2.2.2"
-Flask-Cors = "^3.0.10"
+moto = "^5"
+Flask = "^3"
+Flask-Cors = "^4"
 
 [tool.poetry.scripts]
 fair = 'fair.cli:cli'