rudi-node-write 1.1.1__tar.gz → 1.2.0__tar.gz

{rudi_node_write-1.1.1/src/rudi_node_write.egg-info → rudi_node_write-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rudi-node-write
-Version: 1.1.1
+Version: 1.2.0
 Summary: Use the internal API of a RUDI Producer node
 Author-email: Olivier Martineau <olivier.martineau@irisa.fr>
 Maintainer-email: Olivier Martineau <olivier.martineau@irisa.fr>

{rudi_node_write-1.1.1 → rudi_node_write-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rudi-node-write"
-version = "1.1.1"
+version = "1.2.0"
 authors = [{ name = "Olivier Martineau", email = "olivier.martineau@irisa.fr" }]
 maintainers = [{ name = "Olivier Martineau", email = "olivier.martineau@irisa.fr" }]
 description = "Use the internal API of a RUDI Producer node"
@@ -34,7 +34,7 @@ target-version = ['py311']
 # ----- Tool: commitizen
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "1.1.1"
+version = "1.2.0"
 version_files = ["pyproject.toml:version"]
 
 # ----- Tool: pytest

{rudi_node_write-1.1.1 → rudi_node_write-1.2.0}/src/rudi_node_write/connectors/io_connector.py

@@ -44,12 +44,13 @@ def https_download(resource_url: str, headers=None, should_show_debug_line: bool
 class Connector:
     _default_connector = None
 
-    def __init__(self, server_url: str):
+    def __init__(self, server_url: str, keep_connection: bool = False):
         self.scheme = None
         self.host = None
         self.path = None
         self.base_url = None
         self.connection = None
+        self.keep_connection = keep_connection
 
         self._set_url(server_url)
         self._cookies = None
@@ -63,7 +64,7 @@ class Connector:
         self.host = netloc
         self.path = path
         self.base_url = slash_join(f"{self.scheme}://{self.host}", self.path)
-        log_d(here, "base_url", self.base_url)
+        # log_d(here, "base_url", self.base_url)
 
     @property
     def class_name(self):
@@ -119,7 +120,7 @@ class Connector:
         else:
             log_d_if(should_log_response, here, f"OK {response.status}", path_url)
             res_data = response.read()
-            if not keep_alive:
+            if not keep_alive and not self.keep_connection:
                 self.connection.close()
             if not res_data:
                 log_e(here, "empty data?")
@@ -214,7 +215,7 @@ class Connector:
         except (TypeError, JSONDecodeError):
             response_data = repr(rdata)
             log_d_if(should_log_response, here, "Response is not a JSON", response_data)
-        if not keep_alive:
+        if not keep_alive and not self.keep_connection:
             self.close_connection()
 
         if type(response_data) is str:
@@ -226,7 +227,7 @@ class Connector:
         if response.status >= 400:
             log_e(here, "Connection error", response_data)
             log_e(here, "Request in error", req_method, self.full_url(relative_url))
-            log_e(here, "Headers", response.headers)
+            # log_e(here, "Headers", response.headers)
             raise HttpError(response_data, req_method, self.base_url, relative_url)
 
 

{rudi_node_write-1.1.1 → rudi_node_write-1.2.0}/src/rudi_node_write/connectors/io_rudi_api_write.py

@@ -30,6 +30,8 @@ from rudi_node_write.utils.list_utils import get_first_list_elt_or_none
 from rudi_node_write.utils.log import log_d, log_e, log_w
 from rudi_node_write.utils.str_utils import slash_join, uuid4_str, is_uuid_v4
 from rudi_node_write.utils.typing_utils import get_type_name, check_type
+from rudi_node_write.utils.url_utils import ensure_url_startswith
+
 
 REQ_LIMIT = 500
 _DELAY_REFRESH_S = 60  # seconds
@@ -39,11 +41,13 @@ _STATUS_SKIPPED = "skipped"
 _STATUS_MISSING = "missing"
 _STATUS_DOWNLOADED = "downloaded"
 
-_API_ADMIN_PATH = "api/admin"
-
 here = "RudiNodeApiConnector"
 
 
+def ensure_url_startswith_api_admin(url):
+    return ensure_url_startswith(url, "api/admin")
+
+
 class RudiNodeApiConnector(Connector):
     def __init__(
         self,
@@ -84,7 +88,7 @@ class RudiNodeApiConnector(Connector):
             log_e(here, f"!! Node '{self.host}'", "no connection!")
             raise ConnectionError(f"An error occurred while connecting to RUDI node JWT server {self.base_url}")
 
-        log_d(here, f"Node '{self.host}'", "connection OK")
+        # log_d(here, f"Node '{self.host}'", "connection OK")
         return test
 
     def set_jwt_factory(self, jwt_factory: RudiNodeJwtFactory) -> None:
@@ -112,7 +116,9 @@ class RudiNodeApiConnector(Connector):
     def _headers(self):
         return self._initial_headers | {"Authorization": f"Bearer {self._jwt}"}
 
-    def get_admin_api(self, url: str, keep_alive: bool = False) -> str | int | list | dict:
+    def get_admin_api(
+        self, url: str, keep_alive: bool = False, should_log_request=False, should_log_response=False
+    ) -> str | int | list | dict:
         """
         Performs an identified GET request through /api/admin path
         :param url: part of the URL that comes after /api/admin
@@ -122,9 +128,11 @@ class RudiNodeApiConnector(Connector):
         """
         return self.request(
             req_method="GET",
-            relative_url=slash_join(_API_ADMIN_PATH, url),
+            relative_url=ensure_url_startswith_api_admin(url),
             headers=self._headers,
             keep_alive=keep_alive,
+            should_log_request=should_log_request,
+            should_log_response=should_log_response,
         )  # type: ignore
 
     def put_admin_api(
@@ -138,7 +146,7 @@ class RudiNodeApiConnector(Connector):
         """
         return self.request(
             req_method="PUT",
-            relative_url=slash_join(_API_ADMIN_PATH, url),
+            relative_url=ensure_url_startswith_api_admin(url),
             headers=headers if headers else self._headers,
             body=payload,
             keep_alive=keep_alive,
@@ -155,7 +163,7 @@ class RudiNodeApiConnector(Connector):
         """
         return self.request(
             req_method="POST",
-            relative_url=slash_join(_API_ADMIN_PATH, url),
+            relative_url=ensure_url_startswith_api_admin(url),
             headers=headers if headers else self._headers,
             body=payload,
             keep_alive=keep_alive,
@@ -170,7 +178,7 @@ class RudiNodeApiConnector(Connector):
         """
         return self.request(
             req_method="DELETE",
-            relative_url=slash_join(_API_ADMIN_PATH, url),
+            relative_url=ensure_url_startswith_api_admin(url),
             headers=headers if headers else self._headers,
             keep_alive=keep_alive,
         )

{rudi_node_write-1.1.1 → rudi_node_write-1.2.0}/src/rudi_node_write/connectors/io_rudi_jwt_factory.py

@@ -22,10 +22,14 @@ class RudiNodeJwtFactory(Connector):
         headers_user_agent: str = "RudiNodeJwtFactory",
     ):
         super().__init__(server_url)
+        self.sub = "rudi_prod_token"
         if has_key(auth, B64_AUTH_KEY):
             self._b64_auth = f"Basic {auth[B64_AUTH_KEY]}"
         elif has_key(auth, USR_AUTH_KEY) and has_key(auth, PWD_AUTH_KEY):
             self._b64_auth = get_basic_auth(auth[USR_AUTH_KEY], auth[PWD_AUTH_KEY])
+        elif has_key(auth, "sub"):
+            self.sub = auth["sub"]
+            self._b64_auth = ""
         else:
             err_msg = f"{B64_AUTH_KEY}', or both '{USR_AUTH_KEY}' and '{PWD_AUTH_KEY}"
             raise UnexpectedValueException("auth", err_msg, auth)
@@ -45,7 +49,7 @@ class RudiNodeJwtFactory(Connector):
         if not isinstance(test, dict) or test["RUDI"] != "JWT":
             log_e("RudiNodeJwtFactory", f"!! Node '{self.host}'", "no connection!")
             raise ConnectionError(f"An error occurred while connecting to RUDI node JWT server {self.base_url}")
-        log_d("RudiNodeJwtFactory", f"Node '{self.host}'", "connection OK")
+        # log_d("RudiNodeJwtFactory", f"Node '{self.host}'", "connection OK")
         return True
 
     def _renew_jwt(self, delay_s: int) -> str:
@@ -53,7 +57,7 @@ class RudiNodeJwtFactory(Connector):
             delay_s = self._default_exp_s
         jwt_body = {
             "exp": Date.time_epoch_s(delay_s),
-            "sub": "rudi_prod_token",
+            "sub": self.sub,
             "req_mtd": "all",
             "req_url": "all",
         }

{rudi_node_write-1.1.1 → rudi_node_write-1.2.0}/src/rudi_node_write/connectors/io_rudi_manager_write.py

@@ -27,6 +27,7 @@ from rudi_node_write.utils.log import log_d, log_e, log_w
 from rudi_node_write.utils.str_utils import check_is_uuid4, is_uuid_v4, slash_join, uuid4_str
 from rudi_node_write.utils.type_date import Date
 from rudi_node_write.utils.typing_utils import check_is_int, get_type_name
+from rudi_node_write.utils.url_utils import ensure_url_startswith
 
 
 # Defaults for constructor
@@ -46,12 +47,17 @@ _STATUS_SKIPPED = "skipped"
 _STATUS_MISSING = "missing"
 _STATUS_DOWNLOADED = "downloaded"
 
-# Path constant
-API_DATA = "api/data"
-
 here = "RudiNodeManagerConnector"
 
 
+def ensure_url_startswith_api(url):
+    return ensure_url_startswith(url, "api")
+
+
+def ensure_url_startswith_api_data(url):
+    return ensure_url_startswith(url, "api/data")
+
+
 class RudiNodeManagerConnector(Connector):
     """
     Every RUDI node has a UI module called "RUDI node manager", or "producer node manager" (shortened as "prod-manager")
@@ -64,9 +70,10 @@ class RudiNodeManagerConnector(Connector):
         server_url: str,
         auth: RudiNodeAuth | dict,
         headers_user_agent: str = _DEFAULT_USER_AGENT,
+        keep_connection: bool = False,
     ):
         self.server_url = server_url
-        super().__init__(server_url)
+        super().__init__(server_url=server_url, keep_connection=keep_connection)
 
         if isinstance(auth, RudiNodeAuth):
             self._auth = auth
@@ -76,6 +83,8 @@ class RudiNodeManagerConnector(Connector):
             raise TypeError("Input 'auth' parameter should either be a 'RudiNodeAuth' object or a dict.")
         self._headers_user_agent = headers_user_agent
 
+        self._is_legacy = False
+
         self._cached_pm_jwt = ""
         self._cached_pm_headers = None
 
@@ -87,7 +96,7 @@ class RudiNodeManagerConnector(Connector):
 
         self._data_cache = {}
 
-        self.test_identified_connection()
+        # self.test_identified_connection()
 
     @property
     def _usr(self):
@@ -108,7 +117,7 @@ class RudiNodeManagerConnector(Connector):
         """
         return self.request(
             req_method="GET",
-            relative_url=slash_join("api", url),
+            relative_url=ensure_url_startswith_api(url),
             headers=headers,
             keep_alive=keep_alive,
             should_log_request=should_log_request,
@@ -123,7 +132,7 @@ class RudiNodeManagerConnector(Connector):
         """
         return self.request(
             req_method="PUT",
-            relative_url=slash_join("api", url),
+            relative_url=ensure_url_startswith_api(url),
             headers=headers,
             body=body,
             keep_alive=keep_alive,
@@ -139,7 +148,7 @@ class RudiNodeManagerConnector(Connector):
         """
         return self.request(
             req_method="POST",
-            relative_url=slash_join("api", url),
+            relative_url=ensure_url_startswith_api(url),
             headers=headers,
             body=body,
             keep_alive=keep_alive,
@@ -155,7 +164,7 @@ class RudiNodeManagerConnector(Connector):
         """
         return self.request(
             req_method="DELETE",
-            relative_url=slash_join("api", url),
+            relative_url=ensure_url_startswith_api(url),
             headers=headers,
             keep_alive=keep_alive,
             should_log_request=should_log_request,
@@ -172,7 +181,7 @@ class RudiNodeManagerConnector(Connector):
     def test_identified_connection(self):
         self.test_connection()
         try:
-            self.init_data
+            self._get_api(url="data/uuid", headers=self._pm_headers)
         except HttpError:
             raise ConnectionError(f"Identifiers seem to be not working for the node: {self.server_url}")
 
@@ -228,10 +237,15 @@ class RudiNodeManagerConnector(Connector):
 
     @property
     def node_urls(self):
+        if self._is_legacy:
+            log_w(here, "The server does not know the URL: front/node-urls")
+            return
         try:
             return self._get_cache("front/node-urls")
         except:
             log_w(here, "The server does not know the URL: front/node-urls")
+            self._is_legacy = True
+            return None
 
     @property
     def media_url(self) -> str:
@@ -243,7 +257,7 @@ class RudiNodeManagerConnector(Connector):
                     self._cached_media_url = media_url
                     return self._cached_media_url
             self.set_media_url(slash_join(f"{self.scheme}://{self.host}", "media"))
-        log_d(here, "_cached_media_url:", self._cached_media_url)
+        # log_d(here, "_cached_media_url:", self._cached_media_url)
         return self._cached_media_url
 
     @property
@@ -255,7 +269,7 @@ class RudiNodeManagerConnector(Connector):
             if not isinstance(res, dict):
                 raise TypeError(f"An error occurred while getting Media JWT: got {res}")
             jwt = f'{res.get("token")}'
-            log_d(here, "jwt:", jwt)
+            # log_d(here, "jwt:", jwt)
             if is_jwt_expired(jwt):
                 raise HttpErrorNotFound(f"Could not access a valid JWT, got: {jwt}")
             self._cached_media_jwt = jwt
@@ -281,7 +295,7 @@ class RudiNodeManagerConnector(Connector):
         """
         return self.request(
             req_method="GET",
-            relative_url=slash_join(API_DATA, url),
+            relative_url=ensure_url_startswith_api_data(url),
             headers=self._pm_headers,
             keep_alive=keep_alive,
         )
@@ -297,7 +311,7 @@ class RudiNodeManagerConnector(Connector):
         self._force_clean_cache()
         return self.request(
             req_method="PUT",
-            relative_url=slash_join(API_DATA, url),
+            relative_url=ensure_url_startswith_api_data(url),
             headers=self._pm_headers,
             body=body,
             keep_alive=keep_alive,
@@ -315,7 +329,7 @@ class RudiNodeManagerConnector(Connector):
         self._force_clean_cache()
         return self.request(
             req_method="DELETE",
-            relative_url=slash_join(API_DATA, url),
+            relative_url=ensure_url_startswith_api_data(url),
             headers=self._pm_headers,
             keep_alive=keep_alive,
         )
@@ -371,8 +385,14 @@ class RudiNodeManagerConnector(Connector):
         :param obj_type: one of RUDI object types
         :return: the list of objects for this type
         """
+        here = f"{self.class_name}.get_data"
+
         if obj_type in RUDI_OBJECT_TYPES:
-            return self._get_cache(obj_type)
+            if not (self._is_legacy and obj_type == "media"):
+                return self._get_cache(obj_type)
+            else:
+                log_w(here, "Legacy node, request not available for 'media'")
+                return {}
         else:
             return self._get_cache(slash_join("data", obj_type))
 
@@ -460,10 +480,14 @@ class RudiNodeManagerConnector(Connector):
         :return: the list of the media declared on the RUDI producer node
         """
         fun = here + ".media_list"
-        try:
-            list_medias = self.get_data("media")
-        except:
-            log_w(fun, "Cannot acces /data/media on pm")
+        list_medias = None
+        if not self._is_legacy:
+            try:
+                list_medias = self.get_data("media")
+            except:
+                log_w(fun, f"Cannot acces /data/media on node {self.base_url}")
+                self._is_legacy = True
+
         if not isinstance(list_medias, list) or len(list_medias) == 0:
             medias = {}
             metadatas = self.metadata_list
@@ -1093,7 +1117,16 @@ class RudiNodeManagerConnector(Connector):
         # log_d(here, "media_info", str(media_info))
 
         # Posting the file metadata as a RudiMediaFile object to the RUDI API module through the PM data API
-        api_media_info = self.put_api_data("media", media_info)
+        if not self._is_legacy:
+            try:
+                api_media_info = self.put_api_data("media", media_info)
+            except HttpError:
+                self._is_legacy = True
+                log_w(
+                    here,
+                    "The Manager module for this node cannot commit RudiMediaFile on the Catalog, please handle this by updating the file storage status in the metadata",
+                )
+                return media_info
 
         # Committing the file that has been uploaded
         log_d(here, "zone_name", zone_name)
@@ -1308,15 +1341,17 @@ if __name__ == "__main__":  # pragma: no cover
     text_file = "unicode_chars.txt"
     yaml_file = "RUDI producer internal API - 1.3.0.yml"
     for i, f in enumerate([text_file, yaml_file]):
-        upload_res = pm_connector.post_local_file(slash_join(dwnld_dir, f), media_uuid[i])
-        log_d(tests, f"File '{f}' now available at", upload_res)
-        stored_media_list = [
-            stored_media for stored_media in rudi_media.media_list if stored_media.get("uuid") == media_uuid[i]
-        ]
-        log_d(
-            tests,
-            "stored_media",
-            stored_media_list[0] if len(stored_media_list) > 0 else None,
-        )
-
+        try:
+            upload_res = pm_connector.post_local_file(slash_join(dwnld_dir, f), media_uuid[i])
+            log_d(tests, f"File '{f}' now available at", upload_res)
+            stored_media_list = [
+                stored_media for stored_media in rudi_media.media_list if stored_media.get("uuid") == media_uuid[i]
+            ]
+            log_d(
+                tests,
+                "stored_media",
+                stored_media_list[0] if len(stored_media_list) > 0 else None,
+            )
+        except HttpError as e:
+            log_w(tests, e)
     log_d(tests, "exec. time", time() - begin)

{rudi_node_write-1.1.1 → rudi_node_write-1.2.0}/src/rudi_node_write/connectors/io_rudi_media_write.py

@@ -12,10 +12,15 @@ from rudi_node_write.utils.file_utils import read_json_file, FileDetails
 from rudi_node_write.utils.jwt import get_basic_auth
 from rudi_node_write.utils.log import log_d, log_w
 from rudi_node_write.utils.str_utils import slash_join, uuid4_str
+from rudi_node_write.utils.url_utils import ensure_url_startswith
 
 MAX_SIZE = 524288000  # (== 500 MB)
 
 
+def ensure_url_startswith_media(url):
+    return ensure_url_startswith(url, "media")
+
+
 class FileTooBigException(Exception):
     def __init__(self, file_size):
         super().__init__(
@@ -129,7 +134,7 @@ class RudiNodeMediaConnector(Connector):
         headers: dict | None = None,
     ):
         return self.request(
-            relative_url=slash_join("media", relative_url),
+            relative_url=ensure_url_startswith_media(relative_url),
             headers=headers if headers is not None else self._get_headers(),
             req_method="GET",
         )
@@ -141,7 +146,7 @@ class RudiNodeMediaConnector(Connector):
         headers: dict | None = None,
     ):
         return self.request(
-            relative_url=slash_join("media", relative_url),
+            relative_url=ensure_url_startswith_media(relative_url),
             headers=headers if headers is not None else self._get_headers(),
             body=payload,
             req_method="POST",
@@ -149,7 +154,7 @@ class RudiNodeMediaConnector(Connector):
 
     def _put_api_media(self, relative_url: str, payload: str | dict | BinaryIO, headers: dict | None = None):
         return self.request(
-            relative_url=slash_join("media", relative_url),
+            relative_url=ensure_url_startswith_media(relative_url),
             headers=headers if headers is not None else self._get_headers(),
             body=payload,
             req_method="PUT",

{rudi_node_write-1.1.1 → rudi_node_write-1.2.0}/src/rudi_node_write/rudi_node_writer.py

@@ -28,7 +28,13 @@ _STATUS_DOWNLOADED = "downloaded"
 class RudiNodeWriter:
     _default_getter = None
 
-    def __init__(self, pm_url: str, auth: RudiNodeAuth, headers_user_agent: str = _USER_AGENT_DEFAULT):
+    def __init__(
+        self,
+        pm_url: str,
+        auth: RudiNodeAuth,
+        headers_user_agent: str = _USER_AGENT_DEFAULT,
+        keep_connection: bool = False,
+    ):
         """
         The main object of this library.
         :param pm_url: the URL of the RUDI node
@@ -39,20 +45,30 @@ class RudiNodeWriter:
         self._pm_url = pm_url
         self._auth = auth
         self._headers_user_agent = headers_user_agent
+        self.keep_connection = keep_connection
+
         self._init_pm_connector()
-        self.connector.test_identified_connection()
+        # self.connector.test_identified_connection()
 
     def _init_pm_connector(self) -> None:
         self._pm_connector = RudiNodeManagerConnector(
             server_url=self._pm_url,
             auth=self._auth,
             headers_user_agent=self._headers_user_agent,
+            keep_connection=self.keep_connection,
         )
 
+    def close_connection(self):
+        self._pm_connector.close_connection()
+
     @property
     def headers_user_agent(self) -> str:
         return self._headers_user_agent
 
+    @property
+    def is_legacy(self) -> str:
+        return self._pm_connector._is_legacy
+
     @property
     def connector(self) -> RudiNodeManagerConnector:
         """

{rudi_node_write-1.1.1 → rudi_node_write-1.2.0}/src/rudi_node_write/rudi_types/serializable.py

@@ -24,7 +24,7 @@ class Serializable(ABC):
     def class_name(self):
         return self.__class__.__name__
 
-    def __eq__(self, other):
+    def __eq__(self, other):  # NOSONAR
         here = f"{self.class_name}._eq_"
         if other is None:
             log_d(here, f"Target is null. {self} ≠ {other}")
@@ -36,6 +36,8 @@ class Serializable(ABC):
         other_json = other.to_json()
         if not isinstance(self_json, type(other_json)):
             return False
+        if isinstance(self_json, list) and isinstance(other_json, list):
+            return sorted(self_json) == sorted(other_json)
         if isinstance(self_json, dict) and isinstance(other_json, dict):
             for key in self_json.keys():
                 if (val_b := other_json.get(key)) is None:
@@ -50,8 +52,6 @@ class Serializable(ABC):
                 return True
             log_d(here, f"target still has some unmatched keys: {other_json}")
             return False
-        elif isinstance(self_json, list) and isinstance(other_json, list):
-            return sorted(self_json) == sorted(other_json)
         return self_json == other_json
 
     def __ne__(self, other):

{rudi_node_write-1.1.1 → rudi_node_write-1.2.0}/src/rudi_node_write/utils/err.py

@@ -57,25 +57,28 @@ class ExpiredTokenException(Exception):
             super().__init__(f"JWT has expired: {exp} < {now_epoch_s}")
 
 
-def rudi_api_http_error_to_string(status, err_type, err_msg):
-    return f"HTTP ERR {status} {err_type}: {err_msg}"
-
-
 class HttpError(Exception):
     status = 500
 
     def __init__(self, err, req_method: str | None = None, base_url: str | None = None, url: str | None = None):
         here = "HttpError"
-        err_msg = f"HTTP ERR {self.status} {err}"
+        self.method = req_method
+        self.base_url = base_url
+        self.url = url
         # print(here, f"http err {self.status}:", err)
         if type(err) is dict and "error" in err and "message" in err:
-            if "status" in err:
-                err_msg = rudi_api_http_error_to_string(err["status"], err["error"], err["message"])
-            elif "statusCode" in err:
-                err_msg = rudi_api_http_error_to_string(err["statusCode"], err["error"], err["message"])
+            err_status = err["status"] if "status" in err else err.get("statusCode")
+            err_type = err["error"]
+            err_msg = err["message"]
+            self.message = f"{err_status} {err_type}: {err_msg}"
+        else:
+            self.message = f"{self.status} {err}"
         if req_method and base_url:
-            err_msg = f"HTTP ERR for request '{req_method} {slash_join(base_url, url)}' -> {err}"
-        super().__init__(err_msg)
+            self.message = f"for request '{req_method} {slash_join(base_url, url)}' -> {err}"
+        super().__init__(self.message)
+
+    def __str__(self):
+        return f"HTTP ERR {self.message}"
 
 
 class HttpErrorNotFound(HttpError):

{rudi_node_write-1.1.1 → rudi_node_write-1.2.0}/src/rudi_node_write/utils/file_utils.py

@@ -115,6 +115,7 @@ def get_file_hash(file_local_path: str, hash_algo: str = "md5") -> str:
 
 
 def read_json_file(file_path, mode: Literal["b", "t"] = "t"):  # pragma: no cover
+    check_is_file(file_path)
     with open(file_path, f"r{mode}") as json_file_content:
         json_dict = load(json_file_content)
     return json_dict

{rudi_node_write-1.1.1 → rudi_node_write-1.2.0}/src/rudi_node_write/utils/str_utils.py

@@ -1,4 +1,5 @@
 from re import compile
+from typing import Callable
 from uuid import UUID, uuid4
 
 from rudi_node_write.utils.typing_utils import get_type_name
@@ -81,3 +82,11 @@ def slash_join(*args):
             non_null_args.append(frag.strip("/"))
     joined_str = "/".join(non_null_args)
     return joined_str
+
+
+def ensure_startswith(s: str, test_str: str, start_str: str | None = None, transform: Callable | None = None):
+    if s.startswith(test_str):
+        return s
+    if transform is None:
+        return test_str + s if start_str is None else start_str + s
+    return transform(s)

{rudi_node_write-1.1.1 → rudi_node_write-1.2.0}/src/rudi_node_write/utils/url_utils.py

@@ -2,9 +2,18 @@ from http.client import HTTPResponse
 from urllib.parse import quote
 
 from rudi_node_write.utils.log import log_d
+from rudi_node_write.utils.str_utils import slash_join
 from rudi_node_write.utils.typing_utils import get_type_name
 
 
+def ensure_http(url: str, scheme="https://"):
+    return url if url.startswith("http") else slash_join(scheme, "/", url)
+
+
+def ensure_url_startswith(url: str, str_start: str):
+    return url if url.startswith(str_start) else slash_join(str_start, url)
+
+
 def get_response_cookies(http_response: HTTPResponse):
     cookie_list = http_response.headers.get_all("set-cookie")
     # log_d("get_response_cookies", "cookie_list", cookie_list)