ocrd 3.0.0b4__py3-none-any.whl → 3.0.0b6__py3-none-any.whl

ocrd/cli/bashlib.py

@@ -76,10 +76,10 @@ def bashlib_constants(name):
 @click.option('--ocrd-tool', help="path to ocrd-tool.json of processor to feed", default=None)
 @click.option('--executable', help="name of processor executable in ocrd-tool.json", default=None)
 @click.option('-m', '--mets', help="METS to process", default=DEFAULT_METS_BASENAME)
-@click.option('-w', '--working-dir', help="Working Directory")
+@click.option('-U', '--mets-server-url', help='TCP host URI or UDS path of METS server', default=None)
+@click.option('-d', '--working-dir', help="Working Directory")
 @click.option('-I', '--input-file-grp', help='File group(s) used as input.', default=None)
 @click.option('-O', '--output-file-grp', help='File group(s) used as output.', default=None)
-# repeat some other processor options for convenience (will be ignored here)
 @click.option('-g', '--page-id', help="ID(s) of the pages to process")
 @click.option('--overwrite', is_flag=True, default=False, help="Remove output pages/images if they already exist\n"
               "(with '--page-id', remove only those).\n"
@@ -126,9 +126,10 @@ def bashlib_input_files(ocrd_tool, executable, **kwargs):
             def executable(self):
                 # needed for ocrd_tool lookup
                 return executable
+        processor_class = FullBashlibProcessor
     else:
         # we have no true metadata file, so fill in just to make it work
-        class FullBashlibProcessor(BashlibProcessor):
+        class UnknownBashlibProcessor(BashlibProcessor):
             @property
             def ocrd_tool(self):
                 # needed to satisfy the validator
@@ -142,5 +143,6 @@ def bashlib_input_files(ocrd_tool, executable, **kwargs):
             def version(self):
                 # needed to satisfy the validator and wrapper
                 return '1.0'
+        processor_class = UnknownBashlibProcessor
 
-    ocrd_cli_wrap_processor(FullBashlibProcessor, **kwargs)
+    ocrd_cli_wrap_processor(processor_class, **kwargs)

ocrd/cli/ocrd_tool.py

@@ -125,7 +125,7 @@ def ocrd_tool_tool_list_resources(ctx):
 @click.argument('res_name')
 @pass_ocrd_tool
 def ocrd_tool_tool_resolve_resource(ctx, res_name):
-    ctx.processor(None).resolve_resource(res_name)
+    print(ctx.processor(None).resolve_resource(res_name))
 
 @ocrd_tool_tool.command('show-resource', help="Dump a tool's file resource")
 @click.argument('res_name')

ocrd/cli/validate.py

@@ -102,16 +102,19 @@ def validate_page(page, **kwargs):
 @validate_cli.command('tasks')
 @click.option('--workspace', nargs=1, required=False, help='Workspace directory these tasks are to be run. If omitted, only validate syntax')
 @click.option('-M', '--mets-basename', nargs=1, default=DEFAULT_METS_BASENAME, help='Basename of the METS file, used in conjunction with --workspace')
+@click.option('-U', '--mets-server-url', help='TCP host URI or UDS path of METS server')
 @click.option('--overwrite', is_flag=True, default=False, help='When checking against a concrete workspace, simulate overwriting output or page range.')
 @click.option('-g', '--page-id', help="ID(s) of the pages to process")
 @click.argument('tasks', nargs=-1, required=True)
-def validate_process(tasks, workspace, mets_basename, overwrite, page_id):
+def validate_process(tasks, workspace, mets_basename, mets_server_url, overwrite, page_id):
     '''
     Validate a sequence of tasks passable to `ocrd process`
     '''
     if workspace:
-        _inform_of_result(validate_tasks([ProcessorTask.parse(t) for t in tasks],
-            Workspace(Resolver(), directory=workspace, mets_basename=mets_basename), page_id=page_id, overwrite=overwrite))
+        _inform_of_result(validate_tasks(
+            [ProcessorTask.parse(t) for t in tasks],
+            Workspace(Resolver(), directory=workspace, mets_basename=mets_basename, mets_server_url=mets_server_url),
+            page_id=page_id, overwrite=overwrite))
     else:
         for t in [ProcessorTask.parse(t) for t in tasks]:
             _inform_of_result(t.validate())

ocrd/cli/workspace.py

@@ -36,6 +36,17 @@ class WorkspaceCtx():
                 = self.resolver.resolve_mets_arguments(directory, mets_url, mets_basename, mets_server_url)
         self.automatic_backup = automatic_backup
 
+    def workspace(self):
+        return Workspace(
+            self.resolver,
+            directory=self.directory,
+            mets_basename=self.mets_basename,
+            automatic_backup=self.automatic_backup,
+            mets_server_url=self.mets_server_url,
+        )
+    def backup_manager(self):
+        return WorkspaceBackupManager(self.workspace())
+
 
 pass_workspace = click.make_pass_decorator(WorkspaceCtx)
 
@@ -138,6 +149,8 @@ def workspace_clone(ctx, clobber_mets, download, file_grp, file_id, page_id, mim
         LOG.warning(DeprecationWarning("Use 'ocrd workspace --directory DIR clone' instead of argument 'WORKSPACE_DIR' ('%s')" % workspace_dir))
         ctx.directory = workspace_dir
 
+    assert not ctx.mets_server_url, \
+        f"clone cannot be performed with METS Server - stop server, rerun without -U {ctx.mets_server_url}"
     workspace = ctx.resolver.workspace_from_url(
         mets_url,
         dst_dir=ctx.directory,
@@ -173,10 +186,12 @@ def workspace_init(ctx, clobber_mets, directory):
     if directory:
         LOG.warning(DeprecationWarning("Use 'ocrd workspace --directory DIR init' instead of argument 'DIRECTORY' ('%s')" % directory))
         ctx.directory = directory
+    assert not ctx.mets_server_url, \
+        f"init cannot be performed with METS Server - stop server, rerun without -U {ctx.mets_server_url}"
     workspace = ctx.resolver.workspace_from_nothing(
         directory=ctx.directory,
         mets_basename=ctx.mets_basename,
-        clobber_mets=clobber_mets
+        clobber_mets=clobber_mets,
     )
     workspace.save_mets()
     print(workspace.directory)
@@ -200,13 +215,7 @@ def workspace_add_file(ctx, file_grp, file_id, mimetype, page_id, ignore, check_
     Add a file or http(s) URL FNAME to METS in a workspace.
     If FNAME is not an http(s) URL and is not a workspace-local existing file, try to copy to workspace.
     """
-    workspace = Workspace(
-        ctx.resolver,
-        directory=ctx.directory,
-        mets_basename=ctx.mets_basename,
-        automatic_backup=ctx.automatic_backup,
-        mets_server_url=ctx.mets_server_url,
-    )
+    workspace = ctx.workspace()
 
     log = getLogger('ocrd.cli.workspace.add')
     if not mimetype:
@@ -313,13 +322,7 @@ def workspace_cli_bulk_add(ctx, regex, mimetype, page_id, file_id, url, local_fi
 
     """
     log = getLogger('ocrd.cli.workspace.bulk-add') # pylint: disable=redefined-outer-name
-    workspace = Workspace(
-        ctx.resolver,
-        directory=ctx.directory,
-        mets_basename=ctx.mets_basename,
-        automatic_backup=ctx.automatic_backup,
-        mets_server_url=ctx.mets_server_url,
-    )
+    workspace = ctx.workspace()
 
     try:
         pat = re.compile(regex)
@@ -455,12 +458,7 @@ def workspace_find(ctx, file_grp, mimetype, page_id, file_id, output_field, incl
     output_field = [snake_to_camel.get(x, x) for x in output_field]
     modified_mets = False
     ret = []
-    workspace = Workspace(
-        ctx.resolver,
-        directory=ctx.directory,
-        mets_basename=ctx.mets_basename,
-        mets_server_url=ctx.mets_server_url,
-    )
+    workspace = ctx.workspace()
     with pushd_popd(workspace.directory):
         for f in workspace.find_files(
                 file_id=file_id,
@@ -510,7 +508,9 @@ def workspace_remove_file(ctx, id, force, keep_file):  # pylint: disable=redefin
     (If any ``ID`` starts with ``//``, then its remainder
      will be interpreted as a regular expression.)
     """
-    workspace = Workspace(ctx.resolver, directory=ctx.directory, mets_basename=ctx.mets_basename, automatic_backup=ctx.automatic_backup)
+    assert not ctx.mets_server_url, \
+        f"remove cannot be performed with METS Server - stop server, rerun without -U {ctx.mets_server_url}"
+    workspace = ctx.workspace()
     for i in id:
         workspace.remove_file(i, force=force, keep_file=keep_file)
     workspace.save_mets()
@@ -528,7 +528,9 @@ def rename_group(ctx, old, new):
     """
     Rename fileGrp (USE attribute ``NEW`` to ``OLD``).
     """
-    workspace = Workspace(ctx.resolver, directory=ctx.directory, mets_basename=ctx.mets_basename)
+    assert not ctx.mets_server_url, \
+        f"rename-group cannot be performed with METS Server - stop server, rerun without -U {ctx.mets_server_url}"
+    workspace = ctx.workspace()
     workspace.rename_file_group(old, new)
     workspace.save_mets()
 
@@ -549,7 +551,9 @@ def remove_group(ctx, group, recursive, force, keep_files):
     (If any ``GROUP`` starts with ``//``, then its remainder
      will be interpreted as a regular expression.)
     """
-    workspace = Workspace(ctx.resolver, directory=ctx.directory, mets_basename=ctx.mets_basename)
+    assert not ctx.mets_server_url, \
+        f"remove-group cannot be performed with METS Server - stop server, rerun without -U {ctx.mets_server_url}"
+    workspace = ctx.workspace()
     for g in group:
         workspace.remove_file_group(g, recursive=recursive, force=force, keep_files=keep_files)
     workspace.save_mets()
@@ -571,7 +575,9 @@ def prune_files(ctx, file_grp, mimetype, page_id, file_id):
     (If any ``FILTER`` starts with ``//``, then its remainder
      will be interpreted as a regular expression.)
     """
-    workspace = Workspace(ctx.resolver, directory=ctx.directory, mets_basename=ctx.mets_basename, automatic_backup=ctx.automatic_backup)
+    assert not ctx.mets_server_url, \
+        f"prune-files cannot be performed with METS Server - stop server, rerun without -U {ctx.mets_server_url}"
+    workspace = ctx.workspace()
     with pushd_popd(workspace.directory):
         for f in workspace.find_files(
             file_id=file_id,
@@ -608,8 +614,7 @@ def clean(ctx, dry_run, directories, path_glob):
     If no PATH_GLOB are specified, then all files and directories
     may match.
     """
-    log = getLogger('ocrd.cli.workspace.clean')
-    workspace = Workspace(ctx.resolver, directory=ctx.directory, mets_basename=ctx.mets_basename, automatic_backup=ctx.automatic_backup)
+    workspace = ctx.workspace()
     allowed_files = [normpath(f.local_filename) for f in workspace.find_files(local_only=True)]
     allowed_files.append(relpath(workspace.mets_target, start=workspace.directory))
     allowed_dirs = set(dirname(path) for path in allowed_files)
@@ -627,7 +632,7 @@ def clean(ctx, dry_run, directories, path_glob):
             if normpath(path) in allowed_files:
                 continue
             if dry_run:
-                log.info('unlink(%s)' % path)
+                ctx.log.info('unlink(%s)' % path)
             else:
                 unlink(path)
         if not directories:
@@ -637,7 +642,7 @@ def clean(ctx, dry_run, directories, path_glob):
             if normpath(path) in allowed_dirs:
                 continue
             if dry_run:
-                log.info('rmdir(%s)' % path)
+                ctx.log.info('rmdir(%s)' % path)
             else:
                 rmdir(path)
 
@@ -651,7 +656,7 @@ def list_groups(ctx):
     """
     List fileGrp USE attributes
     """
-    workspace = Workspace(ctx.resolver, directory=ctx.directory, mets_basename=ctx.mets_basename)
+    workspace = ctx.workspace()
     print("\n".join(workspace.mets.file_groups))
 
 # ----------------------------------------------------------------------
@@ -677,20 +682,16 @@ def list_pages(ctx, output_field, output_format, chunk_number, chunk_index, page
     (If any ``FILTER`` starts with ``//``, then its remainder
      will be interpreted as a regular expression.)
     """
-    workspace = Workspace(ctx.resolver, directory=ctx.directory, mets_basename=ctx.mets_basename)
-    find_kwargs = {}
-    if page_id_range and 'ID' in output_field:
-        find_kwargs['pageId'] = page_id_range
-    page_ids = sorted({x.pageId for x in workspace.mets.find_files(**find_kwargs) if x.pageId})
+    workspace = ctx.workspace()
     ret = []
-
-    if output_field == ['ID']:
-        ret = [[x] for x in page_ids]
-    else:
-        for i, page_div in enumerate(workspace.mets.get_physical_pages(for_pageIds=','.join(page_ids), return_divs=True)):
+    if page_id_range or list(output_field) != ['ID']:
+        for i, page_div in enumerate(workspace.mets.get_physical_pages(for_pageIds=page_id_range, return_divs=True)):
             ret.append([])
             for k in output_field:
                 ret[i].append(page_div.get(k, 'None'))
+    else:
+        for page_id in workspace.mets.physical_pages:
+            ret.append([page_id])
 
     if numeric_range:
         start, end = map(int, numeric_range.split('..'))
@@ -724,7 +725,7 @@ def get_id(ctx):
     """
     Get METS id if any
     """
-    workspace = Workspace(ctx.resolver, directory=ctx.directory, mets_basename=ctx.mets_basename)
+    workspace = ctx.workspace()
     ID = workspace.mets.unique_identifier
     if ID:
         print(ID)
@@ -744,7 +745,7 @@ def set_id(ctx, id):   # pylint: disable=redefined-builtin
 
     Otherwise will create a new <mods:identifier type="purl">{{ ID }}</mods:identifier>.
     """
-    workspace = Workspace(ctx.resolver, directory=ctx.directory, mets_basename=ctx.mets_basename, automatic_backup=ctx.automatic_backup)
+    workspace = ctx.workspace()
     workspace.mets.unique_identifier = id
     workspace.save_mets()
 
@@ -767,7 +768,9 @@ def update_page(ctx, attr_value_pairs, order, orderlabel, contentids, page_id):
     if contentids:
         update_kwargs['CONTENTIDS'] = contentids
     try:
-        workspace = Workspace(ctx.resolver, directory=ctx.directory, mets_basename=ctx.mets_basename, automatic_backup=ctx.automatic_backup)
+        assert not ctx.mets_server_url, \
+            f"update-page cannot be performed with METS Server - stop server, rerun without -U {ctx.mets_server_url}"
+        workspace = ctx.workspace()
         workspace.mets.update_physical_page_attributes(page_id, **update_kwargs)
         workspace.save_mets()
     except Exception as err:
@@ -805,7 +808,9 @@ def merge(ctx, overwrite, force, copy_files, filegrp_mapping, fileid_mapping, pa
     mets_path = Path(mets_path)
     if filegrp_mapping:
         filegrp_mapping = loads(filegrp_mapping)
-    workspace = Workspace(ctx.resolver, directory=ctx.directory, mets_basename=ctx.mets_basename, automatic_backup=ctx.automatic_backup)
+    assert not ctx.mets_server_url, \
+        f"merge cannot be performed with METS Server - stop server, rerun without -U {ctx.mets_server_url}"
+    workspace = ctx.workspace()
     other_workspace = Workspace(ctx.resolver, directory=str(mets_path.parent), mets_basename=str(mets_path.name))
     workspace.merge(
         other_workspace,
@@ -829,11 +834,12 @@ def merge(ctx, overwrite, force, copy_files, filegrp_mapping, fileid_mapping, pa
 # ----------------------------------------------------------------------
 
 @workspace_cli.group('backup')
-@click.pass_context
+@pass_workspace
 def workspace_backup_cli(ctx): # pylint: disable=unused-argument
     """
     Backing and restoring workspaces - dev edition
     """
+    assert not ctx.mets_server_url, "Workspace backups currently not interoperable with METS Server"
 
 @workspace_backup_cli.command('add')
 @pass_workspace
@@ -841,7 +847,7 @@ def workspace_backup_add(ctx):
     """
     Create a new backup
     """
-    backup_manager = WorkspaceBackupManager(Workspace(ctx.resolver, directory=ctx.directory, mets_basename=ctx.mets_basename, automatic_backup=ctx.automatic_backup))
+    backup_manager = ctx.backup_manager()
     backup_manager.add()
 
 @workspace_backup_cli.command('list')
@@ -850,7 +856,7 @@ def workspace_backup_list(ctx):
     """
     List backups
     """
-    backup_manager = WorkspaceBackupManager(Workspace(ctx.resolver, directory=ctx.directory, mets_basename=ctx.mets_basename, automatic_backup=ctx.automatic_backup))
+    backup_manager = ctx.backup_manager()
     for b in backup_manager.list():
         print(b)
 
@@ -862,7 +868,7 @@ def workspace_backup_restore(ctx, choose_first, bak):
     """
     Restore backup BAK
     """
-    backup_manager = WorkspaceBackupManager(Workspace(ctx.resolver, directory=ctx.directory, mets_basename=ctx.mets_basename, automatic_backup=ctx.automatic_backup))
+    backup_manager = ctx.backup_manager()
     backup_manager.restore(bak, choose_first)
 
 @workspace_backup_cli.command('undo')
@@ -871,7 +877,7 @@ def workspace_backup_undo(ctx):
     """
     Restore the last backup
     """
-    backup_manager = WorkspaceBackupManager(Workspace(ctx.resolver, directory=ctx.directory, mets_basename=ctx.mets_basename, automatic_backup=ctx.automatic_backup))
+    backup_manager = ctx.backup_manager()
     backup_manager.undo()
 
 
@@ -888,15 +894,24 @@ def workspace_serve_cli(ctx): # pylint: disable=unused-argument
 @workspace_serve_cli.command('stop')
 @pass_workspace
 def workspace_serve_stop(ctx): # pylint: disable=unused-argument
-    """Stop the METS server"""
-    workspace = Workspace(
-        ctx.resolver,
-        directory=ctx.directory,
-        mets_basename=ctx.mets_basename,
-        mets_server_url=ctx.mets_server_url,
-    )
+    """Stop the METS server (saving changes to disk)"""
+    workspace = ctx.workspace()
     workspace.mets.stop()
 
+@workspace_serve_cli.command('reload')
+@pass_workspace
+def workspace_serve_reload(ctx): # pylint: disable=unused-argument
+    """Reload the METS server from disk"""
+    workspace = ctx.workspace()
+    workspace.mets.reload()
+
+@workspace_serve_cli.command('save')
+@pass_workspace
+def workspace_serve_save(ctx): # pylint: disable=unused-argument
+    """Save the METS changes to disk"""
+    workspace = ctx.workspace()
+    workspace.mets.save()
+
 @workspace_serve_cli.command('start')
 @pass_workspace
 def workspace_serve_start(ctx): # pylint: disable=unused-argument

ocrd/decorators/__init__.py

@@ -13,7 +13,6 @@ from ocrd_utils import (
     redirect_stderr_and_stdout_to_file,
 )
 from ocrd_validators import WorkspaceValidator
-from ocrd_network import ProcessingWorker, ProcessorServer, AgentType
 
 from ..resolver import Resolver
 from ..processor.base import ResourceNotFoundError, run_processor
@@ -23,8 +22,6 @@ from .parameter_option import parameter_option, parameter_override_option
 from .ocrd_cli_options import ocrd_cli_options
 from .mets_find_options import mets_find_options
 
-SUBCOMMANDS = [AgentType.PROCESSING_WORKER, AgentType.PROCESSOR_SERVER]
-
 
 def ocrd_cli_wrap_processor(
     processorClass,
@@ -88,11 +85,9 @@ def ocrd_cli_wrap_processor(
     if list_resources:
         processor.list_resources()
         sys.exit()
-    if subcommand:
+    if subcommand or address or queue or database:
         # Used for checking/starting network agents for the WebAPI architecture
         check_and_run_network_agent(processorClass, subcommand, address, database, queue)
-    elif address or queue or database:
-        raise ValueError(f"Subcommand options --address --queue and --database are only valid for subcommands: {SUBCOMMANDS}")
 
     # from here: single-run processing context
     initLogging()
@@ -162,6 +157,11 @@ def ocrd_cli_wrap_processor(
 def check_and_run_network_agent(ProcessorClass, subcommand: str, address: str, database: str, queue: str):
     """
     """
+    from ocrd_network import ProcessingWorker, ProcessorServer, AgentType
+    SUBCOMMANDS = [AgentType.PROCESSING_WORKER, AgentType.PROCESSOR_SERVER]
+
+    if not subcommand:
+        raise ValueError(f"Subcommand options --address --queue and --database are only valid for subcommands: {SUBCOMMANDS}")
     if subcommand not in SUBCOMMANDS:
         raise ValueError(f"SUBCOMMAND can only be one of {SUBCOMMANDS}")
 

ocrd/decorators/ocrd_cli_options.py

@@ -43,6 +43,7 @@ def ocrd_cli_options(f):
         option('--address', type=ServerAddressParamType()),
         option('--queue', type=QueueServerParamType()),
         option('--database', type=DatabaseParamType()),
+        option('-R', '--resolve-resource'),
         option('-C', '--show-resource'),
         option('-L', '--list-resources', is_flag=True, default=False),
         option('-J', '--dump-json', is_flag=True, default=False),

ocrd/lib.bash

@@ -27,8 +27,8 @@ ocrd__log () {
 ## Ensure minimum version
 # ht https://stackoverflow.com/posts/4025065
 ocrd__minversion () {
-    local minversion_raw="$1"
     set -e
+    local minversion_raw="$1"
     local version_raw=$(ocrd --version|sed 's/ocrd, version //')
     local version_mmp=$(echo "$version_raw" | grep -Eo '([0-9]+\.?){3}')
     local version_prerelease_suffix="${version_raw#$version_mmp}"
@@ -123,6 +123,7 @@ ocrd__usage () {
 ## declare -A ocrd__argv=()
 ## ```
 ocrd__parse_argv () {
+    set -e
 
     # if [[ -n "$ZSH_VERSION" ]];then
     #     print -r -- ${+ocrd__argv} ${(t)ocrd__argv}
@@ -135,11 +136,16 @@ ocrd__parse_argv () {
         ocrd__raise "Must set \$params (declare -A params)"
     fi
 
+    if ! declare -p "params_json" >/dev/null 2>/dev/null ;then
+        ocrd__raise "Must set \$params_json (declare params_json)"
+    fi
+
     if [[ $# = 0 ]];then
         ocrd__usage
         exit 1
     fi
 
+    ocrd__argv[debug]=false
     ocrd__argv[overwrite]=false
     ocrd__argv[profile]=false
     ocrd__argv[profile_file]=
@@ -170,6 +176,7 @@ ocrd__parse_argv () {
             -w|--working-dir) ocrd__argv[working_dir]=$(realpath "$2") ; shift ;;
             -m|--mets) ocrd__argv[mets_file]=$(realpath "$2") ; shift ;;
             -U|--mets-server-url) ocrd__argv[mets_server_url]="$2" ; shift ;;
+            --debug) ocrd__argv[debug]=true ;;
             --overwrite) ocrd__argv[overwrite]=true ;;
             --profile) ocrd__argv[profile]=true ;;
             --profile-file) ocrd__argv[profile_file]=$(realpath "$2") ; shift ;;
@@ -242,17 +249,6 @@ ocrd__parse_argv () {
         trap showtime DEBUG
     fi
 
-    # check fileGrps
-    local _valopts=( --workspace "${ocrd__argv[working_dir]}" --mets-basename "$(basename ${ocrd__argv[mets_file]})" )
-    if [[ ${ocrd__argv[overwrite]} = true ]]; then
-        _valopts+=( --overwrite )
-    fi
-    if [[ -n "${ocrd__argv[page_id]:-}" ]]; then
-        _valopts+=( --page-id "${ocrd__argv[page_id]}" )
-    fi
-    _valopts+=( "${OCRD_TOOL_NAME#ocrd-} -I ${ocrd__argv[input_file_grp]} -O ${ocrd__argv[output_file_grp]} ${__parameters[*]@Q} ${__parameter_overrides[*]@Q}" )
-    ocrd validate tasks "${_valopts[@]}" || exit $?
-
     # check parameters
     local params_parsed retval
     params_parsed="$(ocrd ocrd-tool "$OCRD_TOOL_JSON" tool $OCRD_TOOL_NAME parse-params "${__parameters[@]}" "${__parameter_overrides[@]}")" || {
@@ -261,10 +257,12 @@ ocrd__parse_argv () {
 $params_parsed"
     }
     eval "$params_parsed"
+    params_json="$(ocrd ocrd-tool "$OCRD_TOOL_JSON" tool $OCRD_TOOL_NAME parse-params --json "${__parameters[@]}" "${__parameter_overrides[@]}")"
 
 }
 
 ocrd__wrap () {
+    set -e
 
     declare -gx OCRD_TOOL_JSON="$1"
     declare -gx OCRD_TOOL_NAME="$2"
@@ -272,6 +270,7 @@ ocrd__wrap () {
     shift
     declare -Agx params
     params=()
+    declare -g params_json
     declare -Agx ocrd__argv
     ocrd__argv=()
 
@@ -293,22 +292,26 @@ ocrd__wrap () {
 
     ocrd__parse_argv "$@"
 
-    i=0
-    declare -ag ocrd__files=()
-    while read line; do
-        eval declare -Ag "ocrd__file$i=( $line )"
-        eval "ocrd__files[$i]=ocrd__file$i"
-        let ++i
-    done < <(ocrd bashlib input-files \
+    declare -ag ocrd__files
+    IFS=$'\n'
+    ocrd__files=( $(ocrd bashlib input-files \
                   --ocrd-tool $OCRD_TOOL_JSON \
                   --executable $OCRD_TOOL_NAME \
+                  $(if [[ ${ocrd__argv[debug]} = true ]]; then echo --debug; fi) \
+                  $(if [[ ${ocrd__argv[overwrite]} = true ]]; then echo --overwrite; fi) \
                   -m "${ocrd__argv[mets_file]}" \
+                  -d "${ocrd__argv[working_dir]}" \
+                  ${ocrd__argv[mets_server_url]:+-U} ${ocrd__argv[mets_server_url]:-} \
+                  -p "$params_json" \
                   -I "${ocrd__argv[input_file_grp]}" \
                   -O "${ocrd__argv[output_file_grp]}" \
-                  ${ocrd__argv[page_id]:+-g} ${ocrd__argv[page_id]:-})
+                  ${ocrd__argv[page_id]:+-g} ${ocrd__argv[page_id]:-}) )
+    IFS=$' \t\n'
 }
 
 ## usage: pageId=$(ocrd__input_file 3 pageId)
 ocrd__input_file() {
-    eval echo "\${${ocrd__files[$1]}[$2]}"
+    declare -A input_file
+    eval input_file=( "${ocrd__files[$1]}" )
+    eval echo "${input_file[$2]}"
 }

ocrd/mets_server.py

@@ -88,6 +88,14 @@ class OcrdFileGroupListModel(BaseModel):
         return OcrdFileGroupListModel(file_groups=file_groups)
 
 
+class OcrdPageListModel(BaseModel):
+    physical_pages: List[str] = Field()
+
+    @staticmethod
+    def create(physical_pages: List[str]):
+        return OcrdPageListModel(physical_pages=physical_pages)
+
+
 class OcrdAgentListModel(BaseModel):
     agents: List[OcrdAgentModel] = Field()
 
@@ -210,6 +218,17 @@ class ClientSideOcrdMets:
             ).json()["text"]
             return self.ws_dir_path
 
+    @property
+    def physical_pages(self) -> List[str]:
+        if not self.multiplexing_mode:
+            return self.session.request("GET", f"{self.url}/physical_pages").json()["physical_pages"]
+        else:
+            return self.session.request(
+                "POST",
+                self.url,
+                json=MpxReq.physical_pages(self.ws_dir_path)
+            ).json()["physical_pages"]
+
     @property
     def file_groups(self):
         if not self.multiplexing_mode:
@@ -284,15 +303,17 @@ class ClientSideOcrdMets:
             file_id=ID, page_id=pageId,
             mimetype=mimetype, url=url, local_filename=local_filename
         )
+        # add force+ignore
+        kwargs = {**kwargs, **data.dict()}
 
         if not self.multiplexing_mode:
-            r = self.session.request("POST", f"{self.url}/file", data=data.dict())
-            if not r:
-                raise RuntimeError("Add file failed. Please check provided parameters")
+            r = self.session.request("POST", f"{self.url}/file", data=kwargs)
+            if not r.ok:
+                raise RuntimeError(f"Failed to add file ({str(data)}): {r.json()}")
         else:
-            r = self.session.request("POST", self.url, json=MpxReq.add_file(self.ws_dir_path, data.dict()))
-            if "error" in r:
-                raise RuntimeError(f"Add file failed: Msg: {r['error']}")
+            r = self.session.request("POST", self.url, json=MpxReq.add_file(self.ws_dir_path, kwargs))
+            if not r.ok:
+                raise RuntimeError(f"Failed to add file ({str(data)}): {r.json()[errors]}")
 
         return ClientSideOcrdFile(
             None, fileGrp=file_grp,
@@ -347,6 +368,11 @@ class MpxReq:
         return MpxReq.__args_wrapper(
             ws_dir_path, method_type="GET", response_type="text", request_url="workspace_path", request_data={})
 
+    @staticmethod
+    def physical_pages(ws_dir_path: str) -> Dict:
+        return MpxReq.__args_wrapper(
+            ws_dir_path, method_type="GET", response_type="dict", request_url="physical_pages", request_data={})
+
     @staticmethod
     def file_groups(ws_dir_path: str) -> Dict:
         return MpxReq.__args_wrapper(
@@ -466,6 +492,10 @@ class OcrdMetsServer:
         async def workspace_path():
             return Response(content=workspace.directory, media_type="text/plain")
 
+        @app.get(path='/physical_pages', response_model=OcrdPageListModel)
+        async def physical_pages():
+            return {'physical_pages': workspace.mets.physical_pages}
+
         @app.get(path='/file_groups', response_model=OcrdFileGroupListModel)
         async def file_groups():
             return {'file_groups': workspace.mets.file_groups}
@@ -505,7 +535,8 @@ class OcrdMetsServer:
             page_id: Optional[str] = Form(),
             mimetype: str = Form(),
             url: Optional[str] = Form(None),
-            local_filename: Optional[str] = Form(None)
+            local_filename: Optional[str] = Form(None),
+            force: bool = Form(False),
         ):
             """
             Add a file
@@ -517,7 +548,7 @@ class OcrdMetsServer:
             )
             # Add to workspace
             kwargs = file_resource.dict()
-            workspace.add_file(**kwargs)
+            workspace.add_file(**kwargs, force=force)
             return file_resource
 
         # ------------- #