humalab 0.0.3__py3-none-any.whl → 0.0.4__py3-none-any.whl

humalab/assets/__init__.py

@@ -0,0 +1,4 @@
+from .resource import ResourceManager
+from .files import ResourceFile, URDFFile
+
+__all__ = ["ResourceManager", "ResourceFile", "URDFFile"]

humalab/assets/files/__init__.py

@@ -0,0 +1,4 @@
+from .resource_file import ResourceFile
+from .urdf_file import URDFFile
+
+__all__ = ["ResourceFile", "URDFFile"]

humalab/assets/files/resource_file.py

@@ -0,0 +1,41 @@
+from datetime import datetime
+
+
+class ResourceFile:
+    def __init__(self, 
+                 name: str, 
+                 version: int, 
+                 filename: str,
+                 resource_type: str,
+                 description: str | None = None,
+                 created_at: datetime | None = None):
+        self._name = name
+        self._version = version
+        self._filename = filename
+        self._resource_type = resource_type
+        self._description = description
+        self._created_at = created_at
+
+    @property
+    def name(self) -> str:
+        return self._name
+    
+    @property
+    def version(self) -> int:
+        return self._version
+    
+    @property
+    def filename(self) -> str:
+        return self._filename
+    
+    @property
+    def resource_type(self) -> str:
+        return self._resource_type
+
+    @property
+    def created_at(self) -> datetime | None:
+        return self._created_at
+
+    @property
+    def description(self) -> str | None:
+        return self._description

humalab/assets/files/urdf_file.py

@@ -0,0 +1,65 @@
+from datetime import datetime
+import os
+import glob
+from humalab.assets.files.resource_file import ResourceFile
+from humalab.assets.archive import extract_archive
+
+
+class URDFFile(ResourceFile):
+    def __init__(self, 
+                 name: str, 
+                 version: int,
+                 filename: str,
+                 urdf_filename: str | None = None,
+                 description: str | None = None,
+                 created_at: datetime | None = None,):
+        super().__init__(name=name, 
+                         version=version,
+                         description=description,
+                         filename=filename,
+                         resource_type="URDF", 
+                         created_at=created_at)
+        self._urdf_base_filename = urdf_filename
+        self._urdf_filename, self._root_path = self._extract()
+        self._urdf_filename = os.path.join(self._urdf_filename, self._urdf_filename)
+        
+    def _extract(self):
+        working_path = os.path.dirname(self._filename)
+        if not os.path.exists(working_path):
+            _, ext = os.path.splitext(self._filename)
+            ext = ext.lstrip('.')  # Remove leading dot
+            if ext.lower() != "urdf":
+                extract_archive(self._filename, working_path)
+                try:
+                    os.remove(self._filename)
+                except Exception as e:
+                    print(f"Error removing saved file {self._filename}: {e}")
+        local_filename = self.search_resource_file(self._urdf_base_filename, working_path)
+        if local_filename is None:
+            raise ValueError(f"Resource filename {self._urdf_base_filename} not found in {working_path}")
+        return local_filename, working_path
+
+    def search_resource_file(self, resource_filename: str | None, working_path: str) -> str | None:
+        found_filename = None
+        if resource_filename:
+            search_path = os.path.join(working_path, "**")
+            search_pattern = os.path.join(search_path, resource_filename)
+            files = glob.glob(search_pattern, recursive=True)
+            if len(files) > 0:
+                found_filename = files[0]
+        
+        if found_filename is None:
+            ext = "urdf"
+            search_pattern = os.path.join(working_path, "**", f"*.{ext}")
+            files = glob.glob(search_pattern, recursive=True)
+            if len(files) > 0:
+                found_filename = files[0]
+        return found_filename
+
+    @property
+    def urdf_filename(self) -> str | None:
+        return self._urdf_filename
+    
+    @property
+    def root_path(self) -> str:
+        return self._root_path

humalab/assets/resource_manager.py

@@ -0,0 +1,57 @@
+from humalab.assets.files.resource_file import ResourceFile
+from humalab.humalab_config import HumalabConfig
+from humalab.humalab_api_client import HumaLabApiClient
+from humalab.assets.files.urdf_file import URDFFile
+import os
+from typing import Any
+
+
+class ResourceManager:
+    def __init__(self,
+                 api_key: str | None = None,
+                 host: str | None = None,
+                 timeout: float | None = None):
+        self._humalab_config = HumalabConfig()
+        self._base_url = host or self._humalab_config.base_url
+        self._api_key = api_key or self._humalab_config.api_key
+        self._timeout = timeout or self._humalab_config.timeout
+
+        self._api_client = HumaLabApiClient(base_url=self._base_url,
+                                      api_key=self._api_key,
+                                      timeout=self._timeout)
+        
+    def _asset_dir(self, name: str, version: int) -> str:
+        return os.path.join(self._humalab_config.workspace_path, "assets", name, f"{version}")
+    
+    def _create_asset_dir(self, name: str, version: int) -> bool:
+        asset_dir = self._asset_dir(name, version)
+        if not os.path.exists(asset_dir):
+            os.makedirs(asset_dir, exist_ok=True)
+            return True
+        return False
+
+    def download(self,
+                 name: str, 
+                 version: int | None=None) -> Any:
+        resource = self._api_client.get_resource(name=name, version=version)
+        file_content = self._api_client.download_resource(name="lerobot")
+        filename = os.path.basename(resource['resource_url'])
+        filename = os.path.join(self._asset_dir(name, resource["version"]), filename)
+        if self._create_asset_dir(name, resource["version"]):
+            with open(filename, "wb") as f:
+                f.write(file_content)
+        
+        if resource["resource_type"].lower() == "urdf":
+            return URDFFile(name=resource["name"],
+                            version=resource["version"],
+                            description=resource.get("description"),
+                            filename=filename,
+                            urdf_filename=resource.get("filename"),
+                            created_at=resource.get("created_at"))
+
+        return ResourceFile(name=name, 
+                            version=resource["version"], 
+                            filename=filename,
+                            resource_type=resource["resource_type"],
+                            description=resource.get("description"),
+                            created_at=resource.get("created_at"))

humalab/dists/categorical.py

@@ -20,6 +20,9 @@ class Categorical(Distribution):
         super().__init__(generator=generator)
         self._choices = choices
         self._size = size
+        if weights is not None and not np.isclose(sum(weights), 1.0):
+            weight_sum = sum(weights)
+            weights = [w / weight_sum for w in weights]
         self._weights = weights
 
     def _sample(self) -> int | float | np.ndarray:

humalab/humalab.py

@@ -1,4 +1,8 @@
 from contextlib import contextmanager
+
+from humalab.assets.files.resource_file import ResourceFile
+from humalab.assets.files.urdf_file import URDFFile
+from humalab.assets.resource_manager import ResourceManager
 from humalab.run import Run
 from humalab.humalab_config import HumalabConfig
 from humalab.humalab_api_client import HumaLabApiClient
@@ -131,6 +135,69 @@ if __name__ == "__main__":
         print("Friction: ", scenario.scenario.cup.friction)
         print("Num Objects: ", scenario.scenario.num_objects)
 
+        scenario_string = """
+        scenario:
+          cup:
+            position: "${uniform: [0.7, 0.7, 0.7], 
+                                [1.5, 1.3, 0.7], [2, 3]}"
+            orientation: "${uniform: 0.3, 0.7}"
+            asset: "${categorical: ['lerobot', 'apple2', 'apple3'], [0.1, 0.3, 0.5]}"
+            friction: "${gaussian: 0.3, 0.05}"
+          hello: 13
+          jkjk: test
+          num_objects: "${discrete: 5, 10}"
+          dfdjkjk: "hello"
+        """
+        with init(entity="default",
+            project="test",
+            name="my first run",
+            description="testing the humalab sdk",
+            tags=["tag1", "tag2"],
+            scenario=scenario_string,
+            num_env=None) as run:
+            print(f"Run ID: {run.id}")
+            print(f"Run Name: {run.name}")
+            print(f"Run Description: {run.description}")
+            print(f"Run Tags: {run.tags}")
+            print(f"Run Scenario YAML:\n{run.scenario.yaml}")
+
+            scenario = run.scenario
+            # Simulate some operations
+            print("CUP position: ", scenario.scenario.cup.position)
+            print("CUP orientation: ", scenario.scenario.cup.orientation)
+            print("Asset: ", scenario.scenario.cup.asset)
+            print("Friction: ", scenario.scenario.cup.friction)
+            print("Num Objects: ", scenario.scenario.num_objects)
+            scenario.reset()
+            print("======================SCENARIO RESET==========================")
+            print("CUP position: ", scenario.scenario.cup.position)
+            print("CUP orientation: ", scenario.scenario.cup.orientation)
+            print("Asset: ", scenario.scenario.cup.asset)
+            print("Friction: ", scenario.scenario.cup.friction)
+            print("Num Objects: ", scenario.scenario.num_objects)
+
+        resource = ResourceManager()
+        urdf_file: URDFFile = resource.download(name="lerobot", version=1)
+        print("URDF File: ", urdf_file.filename)
+        print("URDF Description: ", urdf_file.description)
+        print("URDF Created At: ", urdf_file.created_at)
+        print("URDF Root Path: ", urdf_file._root_path)
+        print("URDF Root Path: ", urdf_file._urdf_filename)
+
+        urdf_file: URDFFile = resource.download(name="lerobot")
+        print("URDF File: ", urdf_file.filename)
+        print("URDF Description: ", urdf_file.description)
+        print("URDF Created At: ", urdf_file.created_at)
+        print("URDF Root Path: ", urdf_file._root_path)
+        print("URDF Root Path: ", urdf_file._urdf_filename)
+
+        atlas_file: ResourceFile = resource.download(name="atlas_description_test")
+        print("Atlas File: ", atlas_file.filename)
+        print("Atlas Description: ", atlas_file.description)
+        print("Atlas Created At: ", atlas_file.created_at)
+
+        
+        """
         humalab_config = HumalabConfig()
         base_url = humalab_config.base_url
         api_key = humalab_config.api_key
@@ -147,3 +214,4 @@ if __name__ == "__main__":
         with open(filename, "wb") as f:
             f.write(file_content)
         print(f"Resource file downloaded: {filename}")
+        """

{humalab-0.0.3.dist-info → humalab-0.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: humalab
-Version: 0.0.3
+Version: 0.0.4
 Summary: Python SDK for HumaLab - A platform for adaptive AI validation.
 Home-page: https://github.com/humalab/humalab_sdk
 Author: HumaLab Team

{humalab-0.0.3.dist-info → humalab-0.0.4.dist-info}/RECORD

@@ -1,19 +1,21 @@
 humalab/__init__.py,sha256=LIL4eEPT_Boiond6pZegbAPvZwNX-ZWHHMVPkv3ehcU,140
 humalab/constants.py,sha256=YSiUI7R7g0gkImD6ezufRlOMdIBS5wJ--dLy11Qb2qY,135
-humalab/humalab.py,sha256=8FE6YpoiSMb2I_8RzwvPU-p30_JqrAG7WuKDOQWLGls,5588
+humalab/humalab.py,sha256=gudSi9nWLY09jJk-JJhAr0d5Gzmru4Y7FA2ttO7HXSQ,8617
 humalab/humalab_api_client.py,sha256=V1PSe1pVngfBUJgxWW-lJzrM1ElQH2ZIolHiDieXlec,8806
 humalab/humalab_config.py,sha256=CdjPgZFGYmmeYq5qsL84ZN8tGdoRP2TjaqS3wojKejg,2698
 humalab/humalab_test.py,sha256=X07HDp9JLllGMuJ2kYxs4WB1o1r1VErn30AAvmn4zuM,19005
 humalab/run.py,sha256=QloVqoZAWlBL5eYVCOqdIRWsjaUoY9BVQvd1BvNEgmY,7841
 humalab/scenario.py,sha256=Zc9ymN5VI-cSnXhX7KYQOM62FCCm8GeAYSyUiUBZl_8,8275
 humalab/scenario_test.py,sha256=9AyDj_l_43bO_ovhzhIvADTh4bAkq8YaMnPQ_sRPTog,28604
-humalab/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+humalab/assets/__init__.py,sha256=fTtwY08nfLxv7whDLGAMWRxwBJDrEZFb-1t19M4cxlc,138
 humalab/assets/archive.py,sha256=PALZRnpNExDfXiURVNEj6xxWqcW4nd9UBZ7QIHa8mI8,3119
-humalab/assets/resource_file.py,sha256=u-1VhnO9xG5I8BtxNWalPjrCAAOISty-No0-HtKMilU,630
-humalab/assets/resource_handler.py,sha256=A1fOLBJRzsU7l4Sum4u_Xa8f8uSTVNKyHifFF5WGz5Y,8733
+humalab/assets/resource_manager.py,sha256=GeVfjerdtvRL4njQO8a75bZaOf_h4KdFTwN8h103vsg,2605
+humalab/assets/files/__init__.py,sha256=9XF-Zp2nldx060v8A3tMTcB5o5vJCUTFKF9rrIFZE_s,111
+humalab/assets/files/resource_file.py,sha256=mvwmE13dQWUu4XGi4kL6hzsYadldt3fVkGubRZ1D-6w,1020
+humalab/assets/files/urdf_file.py,sha256=t91OdI5vvpv9-ELLyjrE9mkgd1TT2y3pPVpUYSXKZA0,2647
 humalab/dists/__init__.py,sha256=Q7zQbFGC_CnTgExMcnRtJdqJitqy1oBk4D6Qyvunlqc,387
 humalab/dists/bernoulli.py,sha256=6JdeuEPdoL2hVwcP94anmTbIDk_TsSeUctooCzugQag,1500
-humalab/dists/categorical.py,sha256=V2xyw8w7oWBlB-uryxTlE_EsqGQUI-_G1_d9dhxreik,1861
+humalab/dists/categorical.py,sha256=t0LwN8PKAXa2Qx4RjYRGbTs-6InT3s4Qbi0srr7iDZQ,2025
 humalab/dists/discrete.py,sha256=Yk-JebgGyBgmTrtibmaF5sJLIsdgsCSUwa8arO8XUHQ,2167
 humalab/dists/distribution.py,sha256=t0qTUjS_N0adiy_j2fdf-NHSlRs1pr0swpnszizs04I,1048
 humalab/dists/gaussian.py,sha256=ueGm8CLTj8cVxfU4fi5cQKZVnPRI6dBy_PLzUMqn2-A,1838
@@ -24,9 +26,9 @@ humalab/metrics/__init__.py,sha256=e0PPkAMP5nW-kGfb67SjMMlgxK9Bkp7nQVD-JWoV-qw,2
 humalab/metrics/dist_metric.py,sha256=C7IpdFolw-VpkTHv-HTAK63kafH-WUjRTLxbF7h4W7g,921
 humalab/metrics/metric.py,sha256=W1mWQKEPVs9x257zzJvJQmAadRNnDqGAEU2BAq1skwM,4194
 humalab/metrics/summary.py,sha256=CloYeVkYgZAiaeM2gS6V8_tABukTkxAFJt0mpfmpbLI,2255
-humalab-0.0.3.dist-info/licenses/LICENSE,sha256=Gy0Nw_Z9pbrNSu-loW-PCDWJyrC8eWpIqqIGW-DFtp8,1064
-humalab-0.0.3.dist-info/METADATA,sha256=Fzzn5WuqhYjxVF7cYOUlAxujVrfUOwrvu9JHc7Jdtm8,1704
-humalab-0.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-humalab-0.0.3.dist-info/entry_points.txt,sha256=aY-hS7Kg8y5kGgYA14YmtTz5odBrgJIZ2fQMXAbVW_U,49
-humalab-0.0.3.dist-info/top_level.txt,sha256=hp7XXBDE40hi9T3Jx6mPFc6wJbAMzektD5VWXlSCW6o,8
-humalab-0.0.3.dist-info/RECORD,,
+humalab-0.0.4.dist-info/licenses/LICENSE,sha256=Gy0Nw_Z9pbrNSu-loW-PCDWJyrC8eWpIqqIGW-DFtp8,1064
+humalab-0.0.4.dist-info/METADATA,sha256=TlQItL7q4I-T3NcRMuLKCHcef5Tg85fgMOlY_AEtjbw,1704
+humalab-0.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+humalab-0.0.4.dist-info/entry_points.txt,sha256=aY-hS7Kg8y5kGgYA14YmtTz5odBrgJIZ2fQMXAbVW_U,49
+humalab-0.0.4.dist-info/top_level.txt,sha256=hp7XXBDE40hi9T3Jx6mPFc6wJbAMzektD5VWXlSCW6o,8
+humalab-0.0.4.dist-info/RECORD,,

humalab/assets/resource_file.py

@@ -1,28 +0,0 @@
-
-
-class ResourceFile:
-    def __init__(self, 
-                 name: str, 
-                 version: int, 
-                 resource_type: str, 
-                 filepath: str):
-        self._name = name
-        self._version = version
-        self._resource_type = resource_type
-        self._filepath = filepath
-
-    @property
-    def name(self) -> str:
-        return self._name
-    
-    @property
-    def version(self) -> int:
-        return self._version
-    
-    @property
-    def resource_type(self) -> str:
-        return self._resource_type
-    
-    @property
-    def filepath(self) -> str:
-        return self._filepath

humalab/assets/resource_handler.py

@@ -1,175 +0,0 @@
-import mongoengine as me
-from minio import Minio
-import os
-import glob
-import tempfile
-import trimesh
-from humalab_service.humalab_host import HumaLabHost
-from humalab_service.services.stores.obj_store import ObjStore
-from humalab_service.services.stores.namespace import ObjectType
-from humalab_service.db.resource import ResourceDocument
-from humalab.assets.archive import extract_archive
-
-
-ASSET_TYPE_TO_EXTENSIONS = {
-    "urdf": {"urdf"},
-    "mjcf": {"xml"},
-    "mesh": trimesh.available_formats(),
-    "usd": {"usd"},
-    "controller": {"py"},
-    "global_controller": {"py"},
-    "terminator": {"py"},
-    "data": {},
-}
-
-class ResourceHandler:
-    def __init__(self, working_path: str=tempfile.gettempdir()):
-        self._minio_client = Minio(
-            HumaLabHost.get_minio_service_address(),
-            access_key="humalab",
-            secret_key="humalab123",
-            secure=False
-        )
-        self._obj_store = ObjStore(self._minio_client)
-        self.working_path_root = working_path
-
-    def search_resource_file(self, resource_filename: str | None, working_path: str, morph_type: str) -> str | None:
-        found_filename = None
-        if resource_filename:
-            search_path = os.path.join(working_path, "**")
-            search_pattern = os.path.join(search_path, resource_filename)
-            files = glob.glob(search_pattern, recursive=True)
-            if len(files) > 0:
-                found_filename = files[0]
-        
-        if found_filename is None:
-            for ext in ASSET_TYPE_TO_EXTENSIONS[morph_type]:
-                search_pattern = os.path.join(working_path, "**", f"*.{ext}")
-                files = glob.glob(search_pattern, recursive=True)
-                if len(files) > 0:
-                    found_filename = files[0]
-                    break
-        return found_filename
-    
-    def _save_file(self, filepath: str, data: bytes) -> str:
-        os.makedirs(os.path.dirname(filepath), exist_ok=True)
-        with open(filepath, "wb") as f:
-            f.write(data)
-        return filepath
-
-    def _save_and_extract(self, working_path: str, local_filepath: str, file_content: bytes, file_type: str):
-        os.makedirs(working_path, exist_ok=True)
-        saved_filepath = self._save_file(local_filepath, file_content)
-        _, ext = os.path.splitext(saved_filepath)
-        ext = ext.lstrip('.')  # Remove leading dot
-        if ext not in ASSET_TYPE_TO_EXTENSIONS[file_type]:
-            extract_archive(saved_filepath, working_path)
-            try:
-                os.remove(saved_filepath)
-            except Exception as e:
-                print(f"Error removing saved file {saved_filepath}: {e}")
-
-    def save_file(self,
-                  resource_name: str,
-                  resource_version: int,
-                  object_type: ObjectType,
-                  file_content: bytes,
-                  file_url: str,
-                  resource_type: str,
-                  filename: str | None = None) -> str:
-        working_path = self.get_working_path(object_type, resource_name, resource_version)
-        local_filepath = os.path.join(working_path, os.path.basename(file_url))
-        local_filename = None
-        if os.path.exists(os.path.dirname(working_path)):
-            # if directory exists, try to search for the file
-            local_filename = self.search_resource_file(filename, working_path, resource_type)
-        if local_filename is None:
-            # if not found, save the file and extract the archive,
-            # then search for the file again
-            self._save_and_extract(working_path, local_filepath, file_content, resource_type)
-            local_filename = self.search_resource_file(filename, working_path, resource_type)
-        if local_filename is None:
-            # if still not found, raise an error
-            raise ValueError(f"Resource filename {filename} not found in {working_path}")
-        return local_filename
-
-    def get_working_path(self, obj_type: ObjectType, uuid: str, version: int) -> str:
-        return os.path.join(self.working_path_root, "humalab", obj_type.value, uuid + "_" + str(version))
-
-    def query_and_download_resource(self, resource_name: str, resource_version: int | None = None) -> tuple[str, str]:
-        """ Query the resource from the database and download it from the object store.
-        Args:
-            resource_name (str): The name of the resource.
-            resource_version (int | None): The version of the resource. If None, the latest version will be used.
-        Returns:
-            tuple[str, str]: A tuple containing the local filename of the resource and the working directory
-                where the resource was downloaded and extracted.
-        """
-        me.connect("humalab", host=f"mongodb://{HumaLabHost.get_mongodb_service_address()}")
-        if resource_version is None:
-            resource = ResourceDocument.objects(name=resource_name.strip(), latest=True).first()
-        else:
-            resource = ResourceDocument.objects(name=resource_name.strip(), version=resource_version).first()
-        if resource is None:
-            raise ValueError(f"Resource {resource_name}:{resource_version} not found")
-        return self.download_resource(resource.name, resource.version, resource.file_url, resource.resource_type.value, resource.filename)
-
-    def download_resource(self,
-                           resource_name: str,
-                           resource_version: int,
-                           resource_url: str,
-                           resource_type: str,
-                           resource_filename: str | None = None) -> tuple[str, str]:
-        """ Download a resource from the object store.
-        Args:
-            resource_name (str): The name of the resource.
-            resource_version (int): The version of the resource.
-            resource_url (str): The URL of the resource in the object store.
-            resource_type (str): The type of the resource (e.g., "urdf", "mjcf", "mesh", etc.).
-            resource_filename (str | None): The specific filename to search for within the resource directory. If None, the first file found will be used.
-        Returns:
-            tuple[str, str]: A tuple containing the local filename of the resource and the working directory
-                where the resource was downloaded and extracted.
-        """
-        return self._download_resource(resource_name,
-                                       resource_version,
-                                       ObjectType.RESOURCE,
-                                       resource_url,
-                                       resource_type,
-                                       resource_filename)
-
-    def _download_resource(self,
-                       resource_name: str,
-                       resource_version: int,
-                       object_type: ObjectType,
-                       resource_url: str,
-                       resource_type: str,
-                       resource_filename: str | None = None) -> tuple[str, str]:
-        """
-        Download an asset from the object store and extract it if necessary.
-
-        Args:
-            asset_uuid (str): The UUID of the asset.
-            asset_version (int): The version of the asset.
-            asset_type (ObjectType): The type of the asset (e.g., URDF, MJCF, Mesh, etc.).
-            asset_url (str): The URL of the asset in the object store.
-            asset_file_type (str): The type of the asset file (e.g., "urdf", "mjcf", "mesh", etc.).
-            asset_filename (str | None): The specific filename to search for within the asset directory. If None, the first file found will be used.
-
-        Returns:
-            tuple[str, str]: A tuple containing the local filename of the asset and the working directory
-                where the asset was downloaded and extracted.
-        """
-        working_path = self.get_working_path(object_type, resource_name, resource_version)
-        local_filepath = os.path.join(working_path, os.path.basename(resource_url))
-        if not os.path.exists(working_path):
-            os.makedirs(working_path, exist_ok=True)
-            self._obj_store.download_file(object_type, resource_url, local_filepath)
-            _, ext = os.path.splitext(resource_url)
-            ext = ext.lower().lstrip('.')
-            if ext not in ASSET_TYPE_TO_EXTENSIONS[resource_type]:
-                extract_archive(local_filepath, working_path)
-        local_filename = self.search_resource_file(resource_filename, working_path, resource_type)
-        if local_filename is None:
-            raise ValueError(f"Resource filename {resource_filename} not found in {working_path}")
-        return local_filename, working_path