pybiolib 1.2.1056__py3-none-any.whl → 1.2.1642__py3-none-any.whl

biolib/_internal/templates/gui_template/biolib-sdk.ts

@@ -0,0 +1,37 @@
+interface IBioLibGlobals {
+  getOutputFileData: (path: string) => Promise<Uint8Array>;
+}
+
+declare global {
+  const biolib: IBioLibGlobals;
+}
+
+// DO NOT MODIFY: Development data files are injected at build time from gui/dev-data/ folder
+const DEV_DATA_FILES: Record<string, string> = {};
+
+const devSdkBioLib: IBioLibGlobals = {
+  getOutputFileData: async (path: string): Promise<Uint8Array> => {
+    console.log(`[SDK] getOutputFileData called with path: ${path}`);
+    
+    const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
+    
+    if (typeof DEV_DATA_FILES !== 'undefined' && normalizedPath in DEV_DATA_FILES) {
+      const base64Data = DEV_DATA_FILES[normalizedPath];
+      const binaryString = atob(base64Data);
+      const bytes = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+      }
+      return bytes;
+    }
+    
+    throw new Error(`File not found: ${path}. Add this file to the dev-data/ folder for local development.`);
+  },
+};
+
+const biolib: IBioLibGlobals =
+  process.env.NODE_ENV === "development"
+    ? devSdkBioLib
+    : (window as any).biolib;
+
+export default biolib;

biolib/_internal/templates/gui_template/dev-data/output.json

@@ -0,0 +1,7 @@
+{
+  "message": "Example JSON data for development",
+  "results": [
+    { "id": 1, "value": "Sample result 1" },
+    { "id": 2, "value": "Sample result 2" }
+  ]
+}

biolib/_internal/templates/gui_template/package.json

@@ -14,6 +14,7 @@
   },
   "devDependencies": {
     "@tailwindcss/vite": "4.0.14",
+    "@types/node": "20.17.10",
     "@types/react": "18.3.3",
     "@types/react-dom": "18.3.0",
     "@vitejs/plugin-react": "4.2.1",

biolib/_internal/templates/gui_template/vite-plugin-dev-data.ts

@@ -0,0 +1,49 @@
+import type { Plugin } from 'vite';
+import fs from 'fs';
+import path from 'path';
+
+export function devDataPlugin(): Plugin {
+  let isDev = false;
+  
+  return {
+    name: 'dev-data-plugin',
+    configResolved(config) {
+      isDev = config.mode === 'development';
+    },
+    transform(code: string, id: string) {
+      if (id.endsWith('biolib-sdk.ts')) {
+        let injectedCode: string;
+        
+        if (isDev) {
+          const devDataDir = path.join(__dirname, 'dev-data');
+          const devDataMap: Record<string, string> = {};
+          
+          if (fs.existsSync(devDataDir)) {
+            const files = fs.readdirSync(devDataDir);
+            for (const file of files) {
+              const filePath = path.join(devDataDir, file);
+              if (fs.statSync(filePath).isFile()) {
+                const content = fs.readFileSync(filePath);
+                const base64Content = content.toString('base64');
+                devDataMap[file] = base64Content;
+              }
+            }
+          }
+          
+          const devDataJson = JSON.stringify(devDataMap);
+          injectedCode = code.replace(
+            "const DEV_DATA_FILES = {};",
+            `const DEV_DATA_FILES = ${devDataJson};`
+          );
+        } else {
+          injectedCode = code;
+        }
+        
+        return {
+          code: injectedCode,
+          map: null
+        };
+      }
+    }
+  };
+}

biolib/_internal/templates/gui_template/vite.config.mts

@@ -2,7 +2,8 @@ import { defineConfig } from "vite";
 import react from "@vitejs/plugin-react";
 import tailwindcss from "@tailwindcss/vite";
 import { viteSingleFile } from "vite-plugin-singlefile";
+import { devDataPlugin } from "./gui/vite-plugin-dev-data";
 
 export default defineConfig({
-  plugins: [react(), tailwindcss(), viteSingleFile()],
+  plugins: [react(), tailwindcss(), devDataPlugin(), viteSingleFile()],
 });

biolib/_internal/templates/init_template/.github/workflows/biolib.yml

@@ -11,6 +11,11 @@ jobs:
           - name: Build
             run: docker build -t BIOLIB_REPLACE_DOCKER_TAG:latest .
           - name: Push
-            run: biolib push $([ "$GITHUB_REF_NAME" != "main" ] && echo -n "--dev") BIOLIB_REPLACE_APP_URI
+            run: |
+              if [ "$GITHUB_REF_NAME" == "main" ]; then
+                biolib push BIOLIB_REPLACE_APP_URI
+              else
+                biolib push --dev BIOLIB_REPLACE_APP_URI:latest-dev
+              fi
             env:
               BIOLIB_TOKEN: ${{ secrets.BIOLIB_TOKEN }}

biolib/_internal/templates/init_template/Dockerfile

@@ -1,3 +1,5 @@
+# syntax=docker/dockerfile:1
+
 FROM python:3.13.3-slim
 WORKDIR /home/biolib/
 

biolib/_internal/utils/__init__.py

@@ -1,5 +1,30 @@
 import time
 import uuid
+from fnmatch import fnmatch
+
+from biolib.biolib_binary_format.utils import LazyLoadedFile
+from biolib.typing_utils import Callable, List, Union, cast
+
+PathFilter = Union[str, Callable[[str], bool]]
+
+
+def filter_lazy_loaded_files(files: List[LazyLoadedFile], path_filter: PathFilter) -> List[LazyLoadedFile]:
+    if not (isinstance(path_filter, str) or callable(path_filter)):
+        raise Exception('Expected path_filter to be a string or a function')
+
+    if callable(path_filter):
+        return list(filter(lambda x: path_filter(x.path), files))  # type: ignore
+
+    glob_filter = cast(str, path_filter)
+
+    # since all file paths start with /, make sure filter does too
+    if not glob_filter.startswith('/'):
+        glob_filter = '/' + glob_filter
+
+    def _filter_function(file: LazyLoadedFile) -> bool:
+        return fnmatch(file.path, glob_filter)
+
+    return list(filter(_filter_function, files))
 
 
 def open_browser_window_from_notebook(url_to_open: str) -> None:

biolib/_internal/utils/job_url.py

@@ -0,0 +1,33 @@
+import re
+from urllib.parse import urlparse
+
+import biolib.utils
+from biolib.typing_utils import Optional, Tuple
+
+
+def parse_result_id_or_url(result_id_or_url: str, default_token: Optional[str] = None) -> Tuple[str, Optional[str]]:
+    result_id_or_url = result_id_or_url.strip()
+
+    if '/' not in result_id_or_url:
+        return (result_id_or_url, default_token)
+
+    if not result_id_or_url.startswith('http://') and not result_id_or_url.startswith('https://'):
+        result_id_or_url = 'https://' + result_id_or_url
+
+    parsed_url = urlparse(result_id_or_url)
+
+    if biolib.utils.BIOLIB_BASE_URL:
+        expected_base = urlparse(biolib.utils.BIOLIB_BASE_URL)
+        if parsed_url.scheme != expected_base.scheme or parsed_url.netloc != expected_base.netloc:
+            raise ValueError(f'URL must start with {biolib.utils.BIOLIB_BASE_URL}, got: {result_id_or_url}')
+
+    pattern = r'/results?/(?P<uuid>[a-f0-9-]+)/?(?:\?token=(?P<token>[^&]+))?'
+    match = re.search(pattern, result_id_or_url, re.IGNORECASE)
+
+    if not match:
+        raise ValueError(f'URL must be in format <base_url>/results/<UUID>/?token=<token>, got: {result_id_or_url}')
+
+    uuid = match.group('uuid')
+    token = match.group('token') or default_token
+
+    return (uuid, token)

biolib/_runtime/runtime.py

@@ -37,10 +37,19 @@ class Runtime:
             return None
         return job_requested_machine
 
+    @staticmethod
+    def get_job_requested_spot_machine() -> bool:
+        job_data = Runtime._get_job_data()
+        return job_data.get('job_requested_machine_spot', False)
+
     @staticmethod
     def get_app_uri() -> str:
         return Runtime._get_job_data()['app_uri']
 
+    @staticmethod
+    def get_max_workers() -> int:
+        return Runtime._get_job_data()['job_reserved_machines']
+
     @staticmethod
     def get_secret(secret_name: str) -> bytes:
         assert re.match(

biolib/_session/session.py

@@ -1,21 +1,23 @@
 from biolib import utils
-from biolib._internal.types import Optional
+from biolib.typing_utils import Optional
 from biolib.api.client import ApiClient, ApiClientInitDict
 from biolib.app import BioLibApp
 
 
 class Session:
-    def __init__(self, _init_dict: ApiClientInitDict) -> None:
+    def __init__(self, _init_dict: ApiClientInitDict, _experiment: Optional[str] = None) -> None:
         self._api = ApiClient(_init_dict=_init_dict)
+        self._experiment = _experiment
 
     @staticmethod
-    def get_session(refresh_token: str, base_url: Optional[str] = None, client_type: Optional[str] = None) -> 'Session':
+    def get_session(refresh_token: str, base_url: Optional[str] = None, client_type: Optional[str] = None, experiment: Optional[str] = None) -> 'Session':
         return Session(
             _init_dict=ApiClientInitDict(
                 refresh_token=refresh_token,
                 base_url=base_url or utils.load_base_url_from_env(),
                 client_type=client_type,
-            )
+            ),
+            _experiment=experiment,
         )
 
     def load(self, uri: str, suppress_version_warning: bool = False) -> BioLibApp:
@@ -39,4 +41,4 @@ class Session:
             >>> app = biolib.load('https://biolib.com/biolib/myapp/')
             >>> result = app.cli('--help')
         """
-        return BioLibApp(uri=uri, _api_client=self._api, suppress_version_warning=suppress_version_warning)
+        return BioLibApp(uri=uri, _api_client=self._api, suppress_version_warning=suppress_version_warning, _experiment=self._experiment)

biolib/_shared/types/__init__.py

@@ -0,0 +1,69 @@
+from .account import AccountDict, AccountDetailedDict
+from .account_member import AccountMemberDict
+from .app import AppDetailedDict, AppSlimDict
+from .data_record import (
+    DataRecordDetailedDict,
+    DataRecordSlimDict,
+    DataRecordTypeDict,
+    DataRecordValidationRuleDict,
+    SqliteV1Column,
+    SqliteV1DatabaseSchema,
+    SqliteV1ForeignKey,
+    SqliteV1Table,
+)
+from .experiment import (
+    DeprecatedExperimentDict,
+    ExperimentDetailedDict,
+    ExperimentDict,
+    ResultCounts,
+)
+from .file_node import FileNodeDict, FileZipMetadataDict, ZipFileNodeDict
+from .push import PushResponseDict
+from .resource import ResourceUriDict, SemanticVersionDict
+from .resource_deploy_key import ResourceDeployKeyDict, ResourceDeployKeyWithSecretDict
+from .resource_permission import ResourcePermissionDetailedDict, ResourcePermissionDict
+from .resource_types import ResourceDetailedDict, ResourceDict
+from .resource_version import ResourceVersionDetailedDict, ResourceVersionDict
+from .result import ResultDetailedDict, ResultDict
+from .typing import Optional
+from .user import EnterpriseSettingsDict, UserDetailedDict, UserDict
+
+__all__ = [
+    'AccountDetailedDict',
+    'AccountDict',
+    'AccountMemberDict',
+    'AppDetailedDict',
+    'AppSlimDict',
+    'DataRecordDetailedDict',
+    'DataRecordSlimDict',
+    'DataRecordTypeDict',
+    'DataRecordValidationRuleDict',
+    'DeprecatedExperimentDict',
+    'EnterpriseSettingsDict',
+    'ExperimentDetailedDict',
+    'ExperimentDict',
+    'FileNodeDict',
+    'FileZipMetadataDict',
+    'Optional',
+    'PushResponseDict',
+    'ResourceDeployKeyDict',
+    'ResourceDeployKeyWithSecretDict',
+    'ResourceDetailedDict',
+    'ResourceDict',
+    'ResourcePermissionDetailedDict',
+    'ResourcePermissionDict',
+    'ResourceUriDict',
+    'ResourceVersionDetailedDict',
+    'ResourceVersionDict',
+    'ResultCounts',
+    'ResultDetailedDict',
+    'ResultDict',
+    'SemanticVersionDict',
+    'SqliteV1Column',
+    'SqliteV1DatabaseSchema',
+    'SqliteV1ForeignKey',
+    'SqliteV1Table',
+    'UserDetailedDict',
+    'UserDict',
+    'ZipFileNodeDict',
+]

biolib/_shared/types/resource.py

@@ -0,0 +1,17 @@
+from .typing import Optional, TypedDict
+
+
+class SemanticVersionDict(TypedDict):
+    major: int
+    minor: int
+    patch: int
+
+
+class ResourceUriDict(TypedDict):
+    account_handle_normalized: str
+    account_handle: str
+    resource_name_normalized: Optional[str]
+    resource_name: Optional[str]
+    resource_prefix: Optional[str]
+    version: Optional[SemanticVersionDict]
+    tag: Optional[str]

biolib/_shared/types/resource_deploy_key.py

@@ -0,0 +1,11 @@
+from .typing import TypedDict
+
+
+class ResourceDeployKeyDict(TypedDict):
+    uuid: str
+    created_at: str
+    name: str
+
+
+class ResourceDeployKeyWithSecretDict(ResourceDeployKeyDict):
+    secret_key: str

biolib/{_internal → _shared}/types/resource_permission.py

@@ -1,4 +1,4 @@
-from .resource import ResourceDict
+from .resource_types import ResourceDict
 from .typing import TypedDict
 
 

biolib/_shared/utils/__init__.py

@@ -0,0 +1,7 @@
+from biolib._shared.utils.resource_uri import normalize_resource_name, parse_resource_uri, parse_semantic_version
+
+__all__ = [
+    'normalize_resource_name',
+    'parse_resource_uri',
+    'parse_semantic_version',
+]

biolib/_shared/utils/resource_uri.py

@@ -0,0 +1,75 @@
+import re
+
+from biolib._shared.types import Optional
+from biolib._shared.types.resource import ResourceUriDict, SemanticVersionDict
+from biolib.biolib_errors import BioLibError
+
+URI_REGEX = re.compile(
+    r'^(@(?P<resource_prefix>[\w._-]+)/)?'
+    r'(?P<account_handle>[\w-]+)'
+    r'(/(?P<resource_name>[\w-]+))?'
+    r'(?::(?P<suffix>[^:]+))?$'
+)
+SEMVER_REGEX = re.compile(r'^(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)$')
+TAG_REGEX = re.compile(r'^[a-z0-9-]{1,128}$')
+
+
+def normalize_resource_name(string: str) -> str:
+    return string.replace('-', '_').lower()
+
+
+def parse_semantic_version(semantic_version: str) -> SemanticVersionDict:
+    if match := SEMVER_REGEX.fullmatch(semantic_version):
+        return SemanticVersionDict(
+            major=int(match.group('major')),
+            minor=int(match.group('minor')),
+            patch=int(match.group('patch')),
+        )
+
+    raise ValueError('The version must be a valid semantic version in the format of major.minor.patch (1.2.3).')
+
+
+def parse_resource_uri(uri: str, use_account_as_name_default: bool = True) -> ResourceUriDict:
+    matches = URI_REGEX.match(uri)
+    if matches is None:
+        raise BioLibError(f"Could not parse resource uri '{uri}', uri did not match regex")
+
+    version: Optional[SemanticVersionDict] = None
+    tag: Optional[str] = None
+
+    suffix = matches.group('suffix')
+    if suffix and suffix != '*':
+        try:
+            version = parse_semantic_version(suffix)
+        except ValueError:
+            if TAG_REGEX.fullmatch(suffix):
+                tag = suffix
+            else:
+                raise BioLibError(
+                    f'Invalid version or tag "{suffix}". '
+                    'Versions must be semantic versions like "1.2.3". '
+                    'Tags must be lowercase alphanumeric or dashes and at most 128 characters.'
+                ) from None
+
+    resource_prefix_raw: Optional[str] = matches.group('resource_prefix')
+    resource_prefix = resource_prefix_raw.lower() if resource_prefix_raw is not None else None
+    account_handle: str = matches.group('account_handle')
+    account_handle_normalized: str = normalize_resource_name(account_handle)
+    resource_name: Optional[str] = matches.group('resource_name')
+
+    if resource_name:
+        resource_name_normalized = normalize_resource_name(resource_name)
+    elif use_account_as_name_default:
+        resource_name_normalized = account_handle_normalized
+    else:
+        resource_name_normalized = None
+
+    return ResourceUriDict(
+        resource_prefix=resource_prefix,
+        account_handle=account_handle,
+        account_handle_normalized=account_handle_normalized,
+        resource_name_normalized=resource_name_normalized,
+        resource_name=resource_name if resource_name is not None or not use_account_as_name_default else account_handle,
+        version=version,
+        tag=tag,
+    )

biolib/api/client.py

@@ -8,7 +8,7 @@ from urllib.parse import urlencode, urljoin
 import importlib_metadata
 
 from biolib._internal.http_client import HttpClient, HttpResponse
-from biolib._internal.types.typing import Any, Dict, Optional, TypedDict, Union, cast
+from biolib._shared.types.typing import Any, Dict, Optional, TypedDict, Union, cast
 from biolib.biolib_api_client import BiolibApiClient as DeprecatedApiClient
 from biolib.biolib_errors import BioLibError
 from biolib.biolib_logging import logger

biolib/app/app.py

@@ -1,11 +1,16 @@
+import copy
 import io
 import json
 import os
+import posixpath
 import random
 import string
 from pathlib import Path
 
 from biolib import utils
+from biolib._internal.file_utils import path_to_renamed_path
+from biolib._runtime.runtime import Runtime
+from biolib._shared.utils import parse_resource_uri
 from biolib.api.client import ApiClient
 from biolib.biolib_api_client import JobState
 from biolib.biolib_api_client.app_types import App, AppVersion
@@ -18,14 +23,24 @@ from biolib.compute_node.job_worker.job_worker import JobWorker
 from biolib.experiments.experiment import Experiment
 from biolib.jobs.job import Result
 from biolib.typing_utils import Dict, Optional
-from biolib.utils.app_uri import parse_app_uri
-from biolib._runtime.runtime import Runtime
-from biolib._internal.file_utils import path_to_renamed_path
+
+
+class JsonStringIO(io.StringIO):
+    pass
 
 
 class BioLibApp:
-    def __init__(self, uri: str, _api_client: Optional[ApiClient] = None, suppress_version_warning: bool = False):
+    def __init__(
+        self,
+        uri: str,
+        _api_client: Optional[ApiClient] = None,
+        suppress_version_warning: bool = False,
+        _experiment: Optional[str] = None,
+    ):
         self._api_client: Optional[ApiClient] = _api_client
+        self._experiment = _experiment
+        self._input_uri = uri
+        self._parsed_input_uri = parse_resource_uri(uri)
 
         app_response = BiolibAppApi.get_by_uri(uri=uri, api_client=self._api_client)
         self._app: App = app_response['app']
@@ -33,16 +48,19 @@ class BioLibApp:
         self._app_version: AppVersion = app_response['app_version']
 
         if not suppress_version_warning:
-            parsed_uri = parse_app_uri(uri)
-            if parsed_uri['version'] is None:
+            if self._parsed_input_uri['version'] is None:
                 if Runtime.check_is_environment_biolib_app():
                     logger.warning(
                         f"No version specified in URI '{uri}'. This will use the default version, "
-                        f"which may change behaviour over time. Consider locking down the exact version, "
+                        f'which may change behaviour over time. Consider locking down the exact version, '
                         f"e.g. '{uri}:1.2.3'"
                     )
 
-        logger.info(f'Loaded project {self._app_uri}')
+        if self._parsed_input_uri['tag']:
+            semantic_version = f"{self._app_version['major']}.{self._app_version['minor']}.{self._app_version['patch']}"
+            logger.info(f'Loaded {self._input_uri} (resolved to {semantic_version})')
+        else:
+            logger.info(f'Loaded {self._app_uri}')
 
     def __str__(self) -> str:
         return self._app_uri
@@ -71,7 +89,7 @@ class BioLibApp:
         result_prefix: Optional[str] = None,
         timeout: Optional[int] = None,
         notify: bool = False,
-        machine_count: Optional[int] = None,
+        max_workers: Optional[int] = None,
         experiment: Optional[str] = None,
         temporary_client_secrets: Optional[Dict[str, str]] = None,
         check: bool = False,
@@ -84,7 +102,12 @@ class BioLibApp:
             raise ValueError('The argument "check" cannot be True when blocking is False')
 
         if not experiment_id:
-            experiment_instance = Experiment(experiment) if experiment else Experiment.get_experiment_in_context()
+            experiment_to_use = experiment if experiment is not None else self._experiment
+            experiment_instance: Optional[Experiment]
+            if experiment_to_use:
+                experiment_instance = Experiment(experiment_to_use, _api_client=self._api_client)
+            else:
+                experiment_instance = Experiment.get_experiment_in_context()
             experiment_id = experiment_instance.uuid if experiment_instance else None
 
         module_input_serialized = self._get_serialized_module_input(args, stdin, files)
@@ -111,11 +134,12 @@ class BioLibApp:
             override_command=override_command,
             result_prefix=result_prefix,
             timeout=timeout,
-            requested_machine_count=machine_count,
+            requested_machine_count=max_workers,
             temporary_client_secrets=temporary_client_secrets,
             api_client=self._api_client,
         )
-        logger.info(f'View the result in your browser at: {utils.BIOLIB_BASE_URL}/results/{job.id}/')
+        if utils.IS_RUNNING_IN_NOTEBOOK:
+            logger.info(f'View the result in your browser at: {utils.BIOLIB_BASE_URL}/results/{job.id}/')
         if blocking:
             # TODO: Deprecate utils.STREAM_STDOUT and always stream logs by simply calling job.stream_logs()
             if utils.IS_RUNNING_IN_NOTEBOOK:
@@ -152,6 +176,8 @@ Example: "app.cli('--help')"
     def _get_serialized_module_input(args=None, stdin=None, files=None) -> bytes:
         if args is None:
             args = []
+        else:
+            args = copy.copy(args)
 
         if stdin is None:
             stdin = b''
@@ -173,18 +199,21 @@ Example: "app.cli('--help')"
             for file_path in files:
                 path = Path(file_path)
                 if path.is_dir():
+                    renamed_dir = path_to_renamed_path(file_path)
                     for filename in path.rglob('*'):
                         if filename.is_dir():
                             continue
                         with open(filename, 'rb') as f:
-                            relative_path = filename.relative_to(Path.cwd())
-                            files_dict[path_to_renamed_path(str(relative_path))] = f.read()
+                            relative_to_dir = filename.resolve().relative_to(path.resolve())
+                            files_dict[posixpath.join(renamed_dir, relative_to_dir.as_posix())] = f.read()
                 else:
                     with open(path, 'rb') as f:
                         files_dict[path_to_renamed_path(str(path))] = f.read()
         elif isinstance(files, dict):
             files_dict = {}
             for key, value in files.items():
+                if '//' in key:
+                    raise BioLibError(f"File path '{key}' contains double slashes which are not allowed")
                 if not key.startswith('/'):
                     key = '/' + key
                 files_dict[key] = value
@@ -199,11 +228,13 @@ Example: "app.cli('--help')"
                             files_dict[path_to_renamed_path(arg)] = f.read()
                     elif os.path.isdir(arg):
                         path = Path(arg)
+                        renamed_dir = path_to_renamed_path(arg)
                         for filename in path.rglob('*'):
                             if filename.is_dir():
                                 continue
                             with open(filename, 'rb') as f:
-                                files_dict[path_to_renamed_path(str(filename))] = f.read()
+                                relative_to_dir = filename.resolve().relative_to(path.resolve())
+                                files_dict[posixpath.join(renamed_dir, relative_to_dir.as_posix())] = f.read()
                     args[idx] = path_to_renamed_path(arg, prefix_with_slash=False)
 
                 # support --myarg=file.txt
@@ -214,20 +245,22 @@ Example: "app.cli('--help')"
                             files_dict[path_to_renamed_path(file_path)] = f.read()
                     elif os.path.isdir(file_path):
                         path = Path(file_path)
+                        renamed_dir = path_to_renamed_path(file_path)
                         for filename in path.rglob('*'):
                             if filename.is_dir():
                                 continue
                             with open(filename, 'rb') as f:
-                                files_dict[path_to_renamed_path(str(filename))] = f.read()
-                    args[idx] = (
-                        arg.split('=')[0] + '=' +
-                        path_to_renamed_path(file_path, prefix_with_slash=False)
-                    )
+                                relative_to_dir = filename.resolve().relative_to(path.resolve())
+                                files_dict[posixpath.join(renamed_dir, relative_to_dir.as_posix())] = f.read()
+                    args[idx] = arg.split('=')[0] + '=' + path_to_renamed_path(file_path, prefix_with_slash=False)
                 else:
                     pass  # a normal string arg was given
             else:
                 tmp_filename = f'input_{"".join(random.choices(string.ascii_letters + string.digits, k=7))}'
-                if isinstance(arg, io.StringIO):
+                if isinstance(arg, JsonStringIO):
+                    file_data = arg.getvalue().encode()
+                    tmp_filename += '.json'
+                elif isinstance(arg, io.StringIO):
                     file_data = arg.getvalue().encode()
                 elif isinstance(arg, io.BytesIO):
                     file_data = arg.getvalue()
@@ -246,7 +279,7 @@ Example: "app.cli('--help')"
     def _run_locally(self, module_input_serialized: bytes) -> Result:
         job_dict = BiolibJobApi.create(
             app_version_id=self._app_version['public_id'],
-            app_resource_name_prefix=parse_app_uri(self._app_uri)['resource_name_prefix'],
+            app_resource_name_prefix=parse_resource_uri(self._app_uri)['resource_prefix'],
         )
         job = Result(job_dict)
 
@@ -271,7 +304,7 @@ Example: "app.cli('--help')"
                 continue
 
             if isinstance(value, dict):
-                value = io.StringIO(json.dumps(value))
+                value = JsonStringIO(json.dumps(value))
             elif isinstance(value, (int, float)):  # Cast numeric values to strings
                 value = str(value)