ocrd 3.1.1__py3-none-any.whl → 3.2.0__py3-none-any.whl

ocrd/resource_manager.py

@@ -1,3 +1,4 @@
+from logging import Logger
 from pathlib import Path
 from os.path import join
 from os import environ, listdir, getcwd, unlink
@@ -5,6 +6,7 @@ from shutil import copytree, rmtree, copy
 from fnmatch import filter as apply_glob
 from datetime import datetime
 from tarfile import open as open_tarfile
+from typing import Dict, Optional
 from urllib.parse import urlparse, unquote
 from zipfile import ZipFile
 
@@ -29,6 +31,7 @@ yaml.constructor.SafeConstructor.yaml_constructors['tag:yaml.org,2002:timestamp'
 
 from ocrd_validators import OcrdResourceListValidator
 from ocrd_utils import getLogger, directory_size, get_moduledir, guess_media_type, config
+from ocrd_utils.constants import RESOURCES_DIR_SYSTEM, RESOURCE_TYPES, MIME_TO_EXT
 from ocrd_utils.os import get_processor_resource_types, list_all_resources, pushd_popd, get_ocrd_tool_json
 from .constants import RESOURCE_LIST_FILENAME, RESOURCE_USER_LIST_COMMENT
 
@@ -47,6 +50,10 @@ class OcrdResourceManager:
         self._userdir = userdir
         self.user_list = Path(self.xdg_config_home, 'ocrd', 'resources.yml')
 
+        self.log.info(f"OcrdResourceManager data home path: {self.xdg_data_home}")
+        self.log.info(f"OcrdResourceManager config home path: {self.xdg_config_home}")
+        self.log.info(f"OcrdResourceManager user list path: {self.user_list}")
+
         if not skip_init:
             self.load_resource_list(Path(RESOURCE_LIST_FILENAME))
             if not self.user_list.exists():
@@ -55,6 +62,12 @@ class OcrdResourceManager:
                 self.save_user_list()
             self.load_resource_list(self.user_list)
 
+    def __repr__(self):
+        return f"user_list={str(self.user_list)} " + \
+               f"exists={self.user_list.exists()} " + \
+               f"database: {len(self.database)} executables " + \
+               f"{sum(map(len, self.database.values()))} resources"
+
     @property
     def userdir(self):
         if not self._userdir:
@@ -69,19 +82,22 @@ class OcrdResourceManager:
 
     @property
     def xdg_config_home(self):
-        if self._xdg_config_home:
-            return self._xdg_config_home
-        return config.XDG_CONFIG_HOME
+        if not self._xdg_config_home:
+            self._xdg_config_home = config.XDG_CONFIG_HOME
+        return self._xdg_config_home
 
     def save_user_list(self, database=None):
         if not database:
             database = self.database
+        self.log.info(f"Saving resources to path: {self.user_list}")
+        self._dedup_database()
         with open(self.user_list, 'w', encoding='utf-8') as f:
             f.write(RESOURCE_USER_LIST_COMMENT)
             f.write('\n')
             f.write(safe_dump(database))
 
-    def load_resource_list(self, list_filename, database=None):
+    def load_resource_list(self, list_filename: Path, database=None):
+        self.log.info(f"Loading resources from path: {list_filename}")
         if not database:
             database = self.database
         if list_filename.is_file():
@@ -98,30 +114,36 @@ class OcrdResourceManager:
                 database[executable] = list_loaded[executable] + database[executable]
         return database
 
-    def list_available(self, executable=None, dynamic=True, name=None, database=None, url=None):
+    def _search_executables(self, executable: Optional[str]):
+        skip_executables = ["ocrd-cis-data", "ocrd-import", "ocrd-make"]
+        for exec_dir in environ['PATH'].split(':'):
+            self.log.debug(f"Searching for executables inside path: {exec_dir}")
+            for exec_path in Path(exec_dir).glob(f'{executable}'):
+                if not exec_path.name.startswith('ocrd-'):
+                    self.log.warning(f"OCR-D processor executable '{exec_path}' has no 'ocrd-' prefix")
+                if exec_path.name in skip_executables:
+                    self.log.debug(f"Not an OCR-D processor CLI, skipping '{exec_path}'")
+                    continue
+                self.log.debug(f"Inspecting '{exec_path} --dump-json' for resources")
+                ocrd_tool = get_ocrd_tool_json(exec_path)
+                for res_dict in ocrd_tool.get('resources', ()):
+                    if exec_path.name not in self.database:
+                        self.database[exec_path.name] = []
+                    self.database[exec_path.name].insert(0, res_dict)
+
+    def list_available(
+        self, executable: str = None, dynamic: bool = True, name: str = None, database: Dict = None, url: str = None
+    ):
         """
         List models available for download by processor
         """
         if not database:
             database = self.database
         if not executable:
-            return database.items()
+            return list(database.items())
         if dynamic:
-            skip_executables = ["ocrd-cis-data", "ocrd-import", "ocrd-make"]
-            for exec_dir in environ['PATH'].split(':'):
-                for exec_path in Path(exec_dir).glob(f'{executable}'):
-                    if not exec_path.name.startswith('ocrd-'):
-                        self.log.warning(f"OCR-D processor executable '{exec_path}' has no 'ocrd-' prefix")
-                    if exec_path.name in skip_executables:
-                        self.log.debug(f"Not an OCR-D processor CLI, skipping '{exec_path}'")
-                        continue
-                    self.log.debug(f"Inspecting '{exec_path} --dump-json' for resources")
-                    ocrd_tool = get_ocrd_tool_json(exec_path)
-                    for resdict in ocrd_tool.get('resources', ()):
-                        if exec_path.name not in database:
-                            database[exec_path.name] = []
-                        database[exec_path.name].insert(0, resdict)
-            database = self._dedup_database(database)
+            self._search_executables(executable)
+            self.save_user_list()
         found = False
         ret = []
         for k in database:
@@ -139,7 +161,7 @@ class OcrdResourceManager:
             ret = [(executable, [])]
         return ret
 
-    def list_installed(self, executable=None):
+    def list_installed(self, executable: str = None):
         """
         List installed resources, matching with registry by ``name``
         """
@@ -150,28 +172,24 @@ class OcrdResourceManager:
             # resources we know about
             all_executables = list(self.database.keys())
             # resources in the file system
-            parent_dirs = [join(x, 'ocrd-resources') for x in [self.xdg_data_home, '/usr/local/share']]
+            parent_dirs = [f"{join(self.xdg_data_home, 'ocrd-resources')}", RESOURCES_DIR_SYSTEM]
             for parent_dir in parent_dirs:
                 if Path(parent_dir).exists():
                     all_executables += [x for x in listdir(parent_dir) if x.startswith('ocrd-')]
         for this_executable in set(all_executables):
             reslist = []
-            mimetypes = get_processor_resource_types(this_executable)
             moduledir = get_moduledir(this_executable)
-            for res_filename in list_all_resources(this_executable, moduled=moduledir, xdg_data_home=self.xdg_data_home):
-                res_filename = Path(res_filename)
-                if not '*/*' in mimetypes:
-                    if res_filename.is_dir() and not 'text/directory' in mimetypes:
-                        continue
-                    if res_filename.is_file() and ['text/directory'] == mimetypes:
-                        continue
+            resdict_list = self.list_available(executable=this_executable)[0][1]
+            for res_filename in list_all_resources(this_executable,
+                                                   moduled=moduledir,
+                                                   xdg_data_home=self.xdg_data_home):
+                res_filename = Path(res_filename).resolve()
                 res_name = res_filename.name
                 res_type = 'file' if res_filename.is_file() else 'directory'
                 res_size = res_filename.stat().st_size if res_filename.is_file() else directory_size(res_filename)
-                resdict_list = [x for x in self.database.get(this_executable, []) if x['name'] == res_name]
-                if resdict_list:
-                    resdict = resdict_list[0]
-                elif str(res_filename.parent) == moduledir:
+                if resdict := next((res for res in resdict_list if res['name'] == res_name), False):
+                    pass
+                elif str(res_filename.parent).startswith(moduledir):
                     resdict = {
                         'name': res_name, 
                         'url': str(res_filename), 
@@ -181,28 +199,28 @@ class OcrdResourceManager:
                     }
                 else:
                     resdict = self.add_to_user_database(this_executable, res_filename, resource_type=res_type)
-                resdict['path'] = str(res_filename)
+                # resdict['path'] = str(res_filename)
                 reslist.append(resdict)
             ret.append((this_executable, reslist))
+        self.save_user_list()
         return ret
 
     def add_to_user_database(self, executable, res_filename, url=None, resource_type='file'):
         """
         Add a stub entry to the user resource.yml
         """
-        res_name = Path(res_filename).name
-        self.log.info(f"{executable} resource '{res_name}' ({str(res_filename)}) not a known resource, "
-                      f"creating stub in {self.user_list}'")
+        res_name = res_filename.name
         if Path(res_filename).is_dir():
             res_size = directory_size(res_filename)
         else:
             res_size = Path(res_filename).stat().st_size
-        with open(self.user_list, 'r', encoding='utf-8') as f:
-            user_database = safe_load(f) or {}
+        user_database = self.load_resource_list(self.user_list)
         if executable not in user_database:
             user_database[executable] = []
         resources_found = self.list_available(executable=executable, name=res_name, database=user_database)[0][1]
         if not resources_found:
+            self.log.info(f"{executable} resource '{res_name}' ({str(res_filename)}) not a known resource, "
+                          f"creating stub in {self.user_list}'")
             resdict = {
                 'name': res_name,
                 'url': url if url else '???',
@@ -222,20 +240,45 @@ class OcrdResourceManager:
     def default_resource_dir(self):
         return self.location_to_resource_dir('data')
 
-    def location_to_resource_dir(self, location):
-        return '/usr/local/share/ocrd-resources' if location == 'system' else \
-                join(self.xdg_data_home, 'ocrd-resources') if location == 'data' else \
-                getcwd()
+    def location_to_resource_dir(self, location: str) -> str:
+        if location == 'data':
+            return join(self.xdg_data_home, 'ocrd-resources')
+        if location == 'system':
+            return RESOURCES_DIR_SYSTEM
+        return getcwd()
 
-    def resource_dir_to_location(self, resource_path):
+    def resource_dir_to_location(self, resource_path: Path) -> str:
         resource_path = str(resource_path)
-        return 'system' if resource_path.startswith('/usr/local/share/ocrd-resources') else \
-               'data' if resource_path.startswith(join(self.xdg_data_home, 'ocrd-resources')) else \
-               'cwd' if resource_path.startswith(getcwd()) else \
-               resource_path
+        if resource_path.startswith(RESOURCES_DIR_SYSTEM):
+            return 'system'
+        if resource_path.startswith(join(self.xdg_data_home, 'ocrd-resources')):
+            return 'data'
+        if resource_path.startswith(getcwd()):
+            return 'cwd'
+        return resource_path
+
+    def build_resource_dest_dir(self, location: str, executable: str) -> Path:
+        if location == 'module':
+            base_dir = get_moduledir(executable)
+            if not base_dir:
+                base_dir = self.location_to_resource_dir('data')
+        else:
+            base_dir = self.location_to_resource_dir(location)
+        no_subdir = location in ['cwd', 'module']
+        dest_dir = Path(base_dir) if no_subdir else Path(base_dir, executable)
+        return dest_dir
 
     @staticmethod
-    def parameter_usage(name, usage='as-is'):
+    def remove_resource(log: Logger, resource_path: Path):
+        if resource_path.is_dir():
+            log.info(f"Removing existing target resource directory {resource_path}")
+            rmtree(str(resource_path))
+        else:
+            log.info(f"Removing existing target resource file {resource_path}")
+            unlink(str(resource_path))
+
+    @staticmethod
+    def parameter_usage(name: str, usage: str = 'as-is') -> str:
         if usage == 'as-is':
             return name
         elif usage == 'without-extension':
@@ -243,8 +286,7 @@ class OcrdResourceManager:
         raise ValueError(f"No such usage '{usage}'")
 
     @staticmethod
-    def _download_impl(url, filename, progress_cb=None, size=None):
-        log = getLogger('ocrd.resource_manager._download_impl')
+    def _download_impl(log: Logger, url: str, filename):
         log.info(f"Downloading {url} to {filename}")
         try:
             gdrive_file_id, is_gdrive_download_link = gparse_url(url, warning=False)
@@ -256,13 +298,11 @@ class OcrdResourceManager:
                         if "Content-Disposition" not in r.headers:
                             url = get_url_from_gdrive_confirmation(r.text)
                 except RuntimeError as e:
-                    log.warning("Cannot unwrap Google Drive URL: %s", e)
+                    log.warning(f"Cannot unwrap Google Drive URL: {e}")
             with open(filename, 'wb') as f:
                 with requests.get(url, stream=True) as r:
                     r.raise_for_status()
                     for data in r.iter_content(chunk_size=4096):
-                        if progress_cb:
-                            progress_cb(len(data))
                         f.write(data)
         except Exception as e:
             rmtree(filename, ignore_errors=True)
@@ -270,22 +310,18 @@ class OcrdResourceManager:
             raise e
 
     @staticmethod
-    def _copy_file(src, dst, progress_cb=None):
-        log = getLogger('ocrd.resource_manager._copy_file')
+    def _copy_file(log: Logger, src, dst):
         log.info(f"Copying file {src} to {dst}")
         with open(dst, 'wb') as f_out, open(src, 'rb') as f_in:
             while True:
                 chunk = f_in.read(4096)
                 if chunk:
                     f_out.write(chunk)
-                    if progress_cb:
-                        progress_cb(len(chunk))
                 else:
                     break
 
     @staticmethod
-    def _copy_dir(src, dst, progress_cb=None):
-        log = getLogger('ocrd.resource_manager._copy_dir')
+    def _copy_dir(log: Logger, src, dst):
         log.info(f"Copying dir recursively from {src} to {dst}")
         if not Path(src).is_dir():
             raise ValueError(f"The source is not a directory: {src}")
@@ -293,76 +329,123 @@ class OcrdResourceManager:
         for child in Path(src).rglob('*'):
             child_dst = Path(dst) / child.relative_to(src)
             if Path(child).is_dir():
-                OcrdResourceManager._copy_dir(child, child_dst, progress_cb)
+                OcrdResourceManager._copy_dir(log, child, child_dst)
             else:
-                OcrdResourceManager._copy_file(child, child_dst, progress_cb)
+                OcrdResourceManager._copy_file(log, child, child_dst)
 
     @staticmethod
-    def _copy_impl(src_filename, filename, progress_cb=None):
-        log = getLogger('ocrd.resource_manager._copy_impl')
+    def _copy_impl(log: Logger, src_filename, filename):
         log.info(f"Copying {src_filename} to {filename}")
         if Path(src_filename).is_dir():
-            OcrdResourceManager._copy_dir(src_filename, filename, progress_cb)
+            OcrdResourceManager._copy_dir(log, src_filename, filename)
         else:
-            OcrdResourceManager._copy_file(src_filename, filename, progress_cb)
+            OcrdResourceManager._copy_file(log, src_filename, filename)
+
+    @staticmethod
+    def _extract_archive(log: Logger, tempdir: Path, path_in_archive: str, fpath: Path, archive_fname: str):
+        Path('out').mkdir()
+        with pushd_popd('out'):
+            mimetype = guess_media_type(f'../{archive_fname}', fallback='application/octet-stream')
+            log.info(f"Extracting {mimetype} archive to {tempdir}/out")
+            if mimetype == 'application/zip':
+                with ZipFile(f'../{archive_fname}', 'r') as zipf:
+                    zipf.extractall()
+            elif mimetype in ('application/gzip', 'application/x-xz'):
+                with open_tarfile(f'../{archive_fname}', 'r:*') as tar:
+                    tar.extractall()
+            else:
+                raise RuntimeError(f"Unable to handle extraction of {mimetype} archive")
+            log.info(f"Copying '{path_in_archive}' from archive to {fpath}")
+            if Path(path_in_archive).is_dir():
+                copytree(path_in_archive, str(fpath))
+            else:
+                copy(path_in_archive, str(fpath))
+
+    def copy_resource(
+        self, log: Logger, url: str, fpath: Path, resource_type: str = 'file', path_in_archive: str = '.'
+    ) -> Path:
+        """
+        Copy a local resource to another destination
+        """
+        if resource_type == 'archive':
+            archive_fname = 'download.tar.xx'
+            with pushd_popd(tempdir=True) as tempdir:
+                self._copy_impl(log, url, archive_fname)
+                self._extract_archive(log, tempdir, path_in_archive, fpath, archive_fname)
+        else:
+            self._copy_impl(log, url, fpath)
+        return fpath
+
+    def download_resource(
+        self, log: Logger, url: str, fpath: Path, resource_type: str = 'file', path_in_archive: str = '.'
+    ) -> Path:
+        """
+        Download a resource by URL to a destination directory
+        """
+        if resource_type == 'archive':
+            archive_fname = 'download.tar.xx'
+            with pushd_popd(tempdir=True) as tempdir:
+                self._download_impl(log, url, archive_fname)
+                self._extract_archive(log, tempdir, path_in_archive, fpath, archive_fname)
+        else:
+            self._download_impl(log, url, fpath)
+        return fpath
 
     # TODO Proper caching (make head request for size, If-Modified etc)
-    def download(
-        self, executable, url, basedir, overwrite=False, no_subdir=False, name=None, resource_type='file',
-        path_in_archive='.', progress_cb=None,
-    ):
+    def handle_resource(
+        self, res_dict: Dict, executable: str, dest_dir: Path, any_url: str, overwrite: bool = False,
+        resource_type: str = 'file', path_in_archive: str = '.'
+    ) -> Optional[Path]:
         """
-        Download a resource by URL
+        Download or Copy a resource by URL to a destination directory
         """
-        log = getLogger('ocrd.resource_manager.download')
-        destdir = Path(basedir) if no_subdir else Path(basedir, executable)
-        if not name:
-            url_parsed = urlparse(url)
-            name = Path(unquote(url_parsed.path)).name
-        fpath = Path(destdir, name)
-        is_url = url.startswith('https://') or url.startswith('http://')
+        log = getLogger('ocrd.resource_manager.handle_resource')
+        registered = "registered" if "size" in res_dict else "unregistered"
+        resource_type = res_dict.get('type', resource_type)
+        resource_name = res_dict.get('name', None)
+        path_in_archive = res_dict.get('path_in_archive', path_in_archive)
+
+        if resource_type not in RESOURCE_TYPES:
+            raise ValueError(f"Unknown resource type: {resource_type}, must be one of: {RESOURCE_TYPES}")
+        if any_url:
+            res_dict['url'] = any_url
+        if not resource_name:
+            url_parsed = urlparse(res_dict['url'])
+            resource_name = Path(unquote(url_parsed.path)).name
+            if resource_type == 'archive' and path_in_archive != '.':
+                resource_name = Path(path_in_archive).name
+        if res_dict['url'] == '???':
+            log.warning(f"Skipping user resource {resource_name} since download url is: {res_dict['url']}")
+            return None
+
+        fpath = Path(dest_dir, resource_name)
         if fpath.exists():
             if not overwrite:
                 fpath_type = 'Directory' if fpath.is_dir() else 'File'
                 log.warning(f"{fpath_type} {fpath} already exists but --overwrite is not set, skipping the download")
                 # raise FileExistsError(f"{fpath_type} {fpath} already exists but --overwrite is not set")
                 return fpath
-            if fpath.is_dir():
-                log.info(f"Removing existing target directory {fpath}")
-                rmtree(str(fpath))
-            else:
-                log.info(f"Removing existing target file {fpath}")
-                unlink(str(fpath))
-        destdir.mkdir(parents=True, exist_ok=True)
-        if resource_type in ('file', 'directory'):
-            if is_url:
-                self._download_impl(url, fpath, progress_cb)
-            else:
-                self._copy_impl(url, fpath, progress_cb)
-        elif resource_type == 'archive':
-            archive_fname = 'download.tar.xx'
-            with pushd_popd(tempdir=True) as tempdir:
-                if is_url:
-                    self._download_impl(url, archive_fname, progress_cb)
-                else:
-                    self._copy_impl(url, archive_fname, progress_cb)
-                Path('out').mkdir()
-                with pushd_popd('out'):
-                    mimetype = guess_media_type(f'../{archive_fname}', fallback='application/octet-stream')
-                    log.info(f"Extracting {mimetype} archive to {tempdir}/out")
-                    if mimetype == 'application/zip':
-                        with ZipFile(f'../{archive_fname}', 'r') as zipf:
-                            zipf.extractall()
-                    elif mimetype in ('application/gzip', 'application/x-xz'):
-                        with open_tarfile(f'../{archive_fname}', 'r:*') as tar:
-                            tar.extractall()
-                    else:
-                        raise RuntimeError(f"Unable to handle extraction of {mimetype} archive {url}")
-                    log.info(f"Copying '{path_in_archive}' from archive to {fpath}")
-                    if Path(path_in_archive).is_dir():
-                        copytree(path_in_archive, str(fpath))
-                    else:
-                        copy(path_in_archive, str(fpath))
+            self.remove_resource(log, resource_path=fpath)
+        dest_dir.mkdir(parents=True, exist_ok=True)
+
+        # TODO @mehmedGIT: Consider properly handling cases for invalid URLs.
+        if res_dict['url'].startswith('https://') or res_dict['url'].startswith('http://'):
+            log.info(f"Downloading {registered} resource '{resource_name}' ({res_dict['url']})")
+            if 'size' not in res_dict:
+                with requests.head(res_dict['url']) as r:
+                    res_dict['size'] = int(r.headers.get('content-length', 0))
+            fpath = self.download_resource(log, res_dict['url'], fpath, resource_type, path_in_archive)
+        else:
+            log.info(f"Copying {registered} resource '{resource_name}' ({res_dict['url']})")
+            urlpath = Path(res_dict['url'])
+            res_dict['url'] = str(urlpath.resolve())
+            res_dict['size'] = directory_size(urlpath) if Path(urlpath).is_dir() else urlpath.stat().st_size
+            fpath = self.copy_resource(log, res_dict['url'], fpath, resource_type, path_in_archive)
+
+        if registered == 'unregistered':
+            self.add_to_user_database(executable, fpath, url=res_dict['url'])
+        self.save_user_list()
+        log.info(f"Installed resource {res_dict['url']} under {fpath}")
         return fpath
 
     def _dedup_database(self, database=None, dedup_key='name'):

{ocrd-3.1.1.dist-info → ocrd-3.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ocrd
-Version: 3.1.1
+Version: 3.2.0
 Summary: OCR-D framework
 Author-email: Konstantin Baierer <unixprog@gmail.com>
 License: Apache License 2.0
@@ -16,7 +16,7 @@ Requires-Dist: beanie~=1.7
 Requires-Dist: click>=7
 Requires-Dist: cryptography<43.0.0
 Requires-Dist: Deprecated==1.2.0
-Requires-Dist: docker
+Requires-Dist: docker>=7.1.0
 Requires-Dist: elementpath
 Requires-Dist: fastapi>=0.78.0
 Requires-Dist: filetype

{ocrd-3.1.1.dist-info → ocrd-3.2.0.dist-info}/RECORD

@@ -5,7 +5,7 @@ ocrd/mets_server.py,sha256=EL6CMtVjmVPs9--3Vn-JyhU2VDMNw-6QN_XWRKFp6uk,22451
 ocrd/ocrd-all-tool.json,sha256=EYXmMzP68p3KzL8nUZ16TCX2chQzKkAeISvuXqI_yIw,2094
 ocrd/resolver.py,sha256=Ba9ALQbTXz6_mla4VqN9tAfHoj6aKuNJAU4tIDnjcHE,14952
 ocrd/resource_list.yml,sha256=82-PiqkZnka1kTj3MQqNn4wXWKHHtoFchsQuetWuqFs,2633
-ocrd/resource_manager.py,sha256=kIWDoKxWH4IJE1gcoTcCRQjYjieCqiQclyuyF6Y9b8A,16813
+ocrd/resource_manager.py,sha256=CLwzUnk_uVOauyAPd0KhMjqBHmKNVluvS5QsK5O0m1A,20447
 ocrd/task_sequence.py,sha256=spiaUQaMM7M8WdBDoQGmLuTPm7tOugYXD6rcJ2UXzxw,6991
 ocrd/workspace.py,sha256=-j3X83K0f4vtd5jwfu6_R53RJ2R8gt1HYpyrv8YP2bg,65661
 ocrd/workspace_backup.py,sha256=iab_JjZ_mMP-G8NIUk4PZmfpNlQuGRoqc3NbTSSew1w,3621
@@ -13,12 +13,12 @@ ocrd/workspace_bagger.py,sha256=yU8H3xR5WmQKvgQewac71ie-DUWcfLnMS01D55zsEHQ,1197
 ocrd/cli/__init__.py,sha256=-BiwIakeCkWx0Jd2yX9_ahfdV4VKz_5yqGEJ_2zKakQ,2734
 ocrd/cli/bashlib.py,sha256=ypFBM3-IULz_IEBx0Y04eGt9VbQWwEWm4ujm9g_hPWY,6009
 ocrd/cli/log.py,sha256=6_FrVmTKIIVNUaNLkuOJx8pvPhensHMuayJ0PA7T-XA,1562
-ocrd/cli/network.py,sha256=oWBHFEURxfUdb_t-F4svP_ri7o5mqBoNQnLZLbsZLTA,602
+ocrd/cli/network.py,sha256=LNibNBtHGvtXuEwzFz1bLAfkroLWyMPsadTaNVwzUko,687
 ocrd/cli/ocrd_tool.py,sha256=EyD5VdLm2WTzQnR-hZKpn-D4-dsWr2PIE5IoY1O3mfE,7357
 ocrd/cli/process.py,sha256=8KD0i7LT01H9u5CC1vktYMEVpS67da_rp_09_EOECmw,1233
-ocrd/cli/resmgr.py,sha256=mk8KZweC_7ENAFnC6FvFf7Zv_W1wqJTmk0EMd9XSvf4,10132
+ocrd/cli/resmgr.py,sha256=h9cSbp3_4sHkBqhWU7cThoUxcIqgrtD81st2nxZdnaw,8024
 ocrd/cli/validate.py,sha256=nvageDaHCETcE71X5lu7i_4JKpgo9MrvJKinVPLYUTI,5727
-ocrd/cli/workspace.py,sha256=KTbSzIUrba5WoYETvM9ElRZVsDUHCGVvjoFgBGZS2nU,40468
+ocrd/cli/workspace.py,sha256=bsp6YXEgwABIUFbSENmxV1c4oxRwc2L-BpeDPlYfhHE,40501
 ocrd/cli/zip.py,sha256=MMJLw3OXWiJVfVtrdJcBkbB8vA1IzSautluazZRuCQ0,5910
 ocrd/decorators/__init__.py,sha256=PyXX7vxdWkRHixas9dWUtyO3YLczcly8ZEpfZDSMVp8,7639
 ocrd/decorators/loglevel_option.py,sha256=tgipROEu3t4hkwWvFssd80k2SbTBwBIC4WNE6Gc-XAg,798
@@ -26,7 +26,7 @@ ocrd/decorators/mets_find_options.py,sha256=d4oATKMP6bFQHNqOK6nLqgUiWF2FYdkPvzkT
 ocrd/decorators/ocrd_cli_options.py,sha256=lIvtE8re1VmpHm45u71ltE0QJS8nyd28HhLC7zGSvlo,2691
 ocrd/decorators/parameter_option.py,sha256=n8hYw7XVTd3i3tvpK8F1Jx_CqRp6EGF9qJVH95yj92Q,1076
 ocrd/processor/__init__.py,sha256=39ymNwYRdc-b_OJzzKmWCvo2ga3KdsGSYDHE1Hzkn_w,274
-ocrd/processor/base.py,sha256=GcfVrgCvfHbrxngwl1VzcaZ5z7QV2e1Cn7CIjBYdcHc,59480
+ocrd/processor/base.py,sha256=tKN-xyPehFpwV3ztyLcOcuA_fWTNdRKu5E8V_jKOO2g,59400
 ocrd/processor/helpers.py,sha256=gIc6PdvOS1sR0UkYlrdZopImAXxXglDBNpgNZGWHO7Y,10987
 ocrd/processor/ocrd_page_result.py,sha256=eDkpyVHcpaBzTHXiGrcNk9PP9Xr-XZru2w_uoX_ZeNA,510
 ocrd/processor/builtin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -36,7 +36,7 @@ ocrd/processor/builtin/dummy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 ocrd/processor/builtin/dummy/ocrd-tool.json,sha256=VoI37paWiUyMkTN5Qqau8R1Clmw24-HcZu4wjy1Br9Y,2311
 ocrd_modelfactory/__init__.py,sha256=NyJT1uSvmeEwibRFOkh0AEoVnYfP0mzxU--pP23B-TQ,4404
 ocrd_models/__init__.py,sha256=A0aj0mOraNb-xfiUueACdoaqISnp0qH-F49nTJg2vCs,380
-ocrd_models/constants.py,sha256=fI6Qz4OPOm6UBLQ_P2dlpjcwB0XFJZ7AgxxKqgc75X0,2724
+ocrd_models/constants.py,sha256=kvvAAro_1YOTRWwFgbrGEFeDZ8_u0S624Y3icNNk4Oo,2987
 ocrd_models/mets-empty.xml,sha256=dFixfbxSXrgjZx9BfdIKWHX-khNmp7dNYaFe2qQSwCY,1203
 ocrd_models/ocrd_agent.py,sha256=E9OtDhz9UfKb6ou2qvsuCL9NlO1V6zMb0s8nVq8dVos,5609
 ocrd_models/ocrd_exif.py,sha256=wRSprHxCy9LCXw41Fi9kp-CbFc5NFX9ZFIFNszB41qk,4585
@@ -48,26 +48,28 @@ ocrd_models/ocrd_xml_base.py,sha256=OW57mXLlwm1nH8CNefvXmwLRws9KL9zSrb-3vH--mX8,
 ocrd_models/report.py,sha256=luZxvzAAQyGYOlRNSJQUIUIANG81iGmBW5ag-uXxKCA,2026
 ocrd_models/utils.py,sha256=0_WHf5NEn1WC8MKJc6X_RK8gW-70Z09_mslkKOj7uF8,2369
 ocrd_models/xpath_functions.py,sha256=AwR8tHf56-mmIksnw_GeOQ760sxNHqK92T7z9OfsEEs,1437
-ocrd_network/__init__.py,sha256=gMejC614J5PPGgXDKBiQS0jt-Jx8qOrLbWH7zt8x8Gs,374
+ocrd_network/__init__.py,sha256=tLSOf5iTNSWjOWep_xY1sU2YZJu7uv9-3qLMuLrwyoU,433
 ocrd_network/client.py,sha256=rzqtamZ8krRRy-QTO-AeWH8Lr3HhRiQe2R1-Lovd40g,3020
 ocrd_network/client_utils.py,sha256=VVZMNBgGznh41exZ78S48X3DDwHcWTuOq-LNdxjRvak,5002
-ocrd_network/constants.py,sha256=IeNtcU6dqonDE3Zw83_61auhS8X2b8wsjAxYg1zvK-M,1902
+ocrd_network/constants.py,sha256=fxbC4QyeQp38KDRWjqnbfYjt3nUx6xT_mkmDt6PylyY,2033
 ocrd_network/database.py,sha256=fcft7vdRDoR7vmPL1xNYTIeOg5DwRPcggwYDYxLy5ik,10706
-ocrd_network/logging_utils.py,sha256=bO9TQqBXw9CIZEKp8tHXbeE2NuJWMiaQDHzS05b4ajo,2153
+ocrd_network/logging_utils.py,sha256=mNYaLmKIf2Wg1gCU_FbicJC54mPhYPEVinmB7rHEdUs,2374
 ocrd_network/param_validators.py,sha256=Jl1VwiPPKJ50k-xEHLdvW-1QDOkJHCiMz4k9Ipqm-Uc,1489
 ocrd_network/process_helpers.py,sha256=KpkInXsa5bgrxvTOouyMJ0NgJhaz0J9Gjs5sZHBcH64,2373
 ocrd_network/processing_server.py,sha256=qBiYk4wgTLqhHvbmDWu_F626BfSfyvkoCD-i0ZwsBSE,42109
 ocrd_network/processing_worker.py,sha256=fhIvmDQAYOkHYtUs5IB8Jk2lOKUTIBk3DskAsFloijA,12591
 ocrd_network/processor_server.py,sha256=2CD9TlinXk6x1jFjP5VWOXgJe8lAQdxc9zjZuVy3EOw,9931
+ocrd_network/resource_manager_server.py,sha256=dFFWsp1O7H3RzdjbQC_fn1SVV1QIjkVbg2l98MMh-HI,6852
 ocrd_network/server_cache.py,sha256=LpvJ-_Lbaeo4M3t8rZDdm9DAErZr8lDlma6pYc0m7aQ,13149
 ocrd_network/server_utils.py,sha256=Uge5F2VagPAEpcyU_Qf8AiecObIGXE0ilD8DaK7bTdE,12222
 ocrd_network/tcp_to_uds_mets_proxy.py,sha256=yRW-O6ihd31gf7xqQBIBb_ZQQgqisMyOdRI216ehq_A,3160
 ocrd_network/utils.py,sha256=XzPXeSPCVjWLQM540PCpxfJ5hqjJ85_OQBjnf9HlDtE,6759
-ocrd_network/cli/__init__.py,sha256=F7YVqxw-9glz6-ghG0Kp5XXeV1-rL1emVSXLCWxdTF0,306
+ocrd_network/cli/__init__.py,sha256=YLt1LAcWrl1YfA_UsLYwWUGYsX84wCd1AZwgsUqjHC8,396
 ocrd_network/cli/client.py,sha256=gFEXjz-d074CpvimqaM4kJRbJVNYRAOK-jsUl2EAUVs,8424
 ocrd_network/cli/processing_server.py,sha256=rAci6RsHlZ0c87GuLdfdCQCiGNcDEu4NEEQiwKJqVUo,796
 ocrd_network/cli/processing_worker.py,sha256=ZuaCkbKV_WKJV7cGOjZ6RLrjjppymnwNCiznFMlclAg,1897
 ocrd_network/cli/processor_server.py,sha256=Vto7UekFo_g83aHqwDmhge9bhPzk0b7O-L46dSfIpJc,1259
+ocrd_network/cli/resmgr_server.py,sha256=sc0VX_RehTbg8Qp7ht_DvVqsrdL5b9Zw3bBgWcAD13A,826
 ocrd_network/models/__init__.py,sha256=AcpZrenygOudMi47Wfr1UCrpbghq2gP8aMAKodgEIFM,527
 ocrd_network/models/job.py,sha256=2-E1cKfdTC3Y5AUemCLz1a_t7BlT8BNF6teAC0f8J5o,4442
 ocrd_network/models/messages.py,sha256=XnyLMX77NchgmtKJRtqtBFsk_sCR4OGEuWm_d3uDkj8,657
@@ -85,18 +87,18 @@ ocrd_network/runtime_data/__init__.py,sha256=3jYkmT4mxMUcpbDaSw7Ld0KTedGEx_5vUQP
 ocrd_network/runtime_data/config_parser.py,sha256=Vr0FbsqmsoiuhDgZ7KFdeFZj9JvUulcOS2PCRFQQNHY,2364
 ocrd_network/runtime_data/connection_clients.py,sha256=DZyAvkNyMaIddGJs56s2pMP_fK-XWAtICxk1cjvkWYM,4207
 ocrd_network/runtime_data/deployer.py,sha256=LkDUG0uJf_V4SteiOM3EWwhKtdANCjmAOEAJJDshN30,9111
-ocrd_network/runtime_data/hosts.py,sha256=ml19ptzH4TFofyJR-Qp_Mn3sZUFbWoNe__rRXZSj_WE,12185
-ocrd_network/runtime_data/network_agents.py,sha256=5p_zKLqECBIHLw-Ya6eKcKSZcUM4ESiipEIphVxHBEA,5192
+ocrd_network/runtime_data/hosts.py,sha256=QkluX5aMCliE8YoH0rJcc9pNprx2Mw5l8_eOq5NJ74s,12319
+ocrd_network/runtime_data/network_agents.py,sha256=uJA6bB8O5XUvRc-wG4b4YKuArQOrQXKJMpMq1TC5bco,6289
 ocrd_network/runtime_data/network_services.py,sha256=xrPpFUU_Pa-XzGe2FEt5RmO17xqykIUmTr_9g6S7XSs,7892
-ocrd_utils/__init__.py,sha256=U_zAQJwxg_aJ4CR84CKMNAUP6Cob8Er8Ikj42JmnUKo,5977
+ocrd_utils/__init__.py,sha256=mdLZyNz2W8t3ht8JMvbGaEfvQmYqXCWLBFcJXY6_fmA,6020
 ocrd_utils/config.py,sha256=1_8j4kpKK5gxhFKObbBEzmq4JazTtKEkGe14Ch_tpw0,11796
-ocrd_utils/constants.py,sha256=ImbG1d8t2MW3uuFi-mN6aY90Zn74liAKZBKlfuKN86w,3278
+ocrd_utils/constants.py,sha256=6lqMLeJdkFBlvGVmGjcExWbRKzNU6QT0kADBb5BkcBc,3464
 ocrd_utils/deprecate.py,sha256=4i50sZsA3Eevqn5D-SL5yGf9KEZfGCV4A5Anzn1GRMs,1026
 ocrd_utils/image.py,sha256=zNNX1cnRy6yvrxx8mnYQiqWraAh5-i4a1AOfCCg4SmI,24781
 ocrd_utils/introspect.py,sha256=gfBlmeEFuRmRUSgdSK0jOxRpYqDRXl2IAE6gv2MZ6as,1977
 ocrd_utils/logging.py,sha256=sHNfih9kBfvKsHdLqMK_ew9Pld1GsRyYlrZHIySujnw,7313
 ocrd_utils/ocrd_logging.conf,sha256=JlWmA_5vg6HnjPGjTC4mA5vFHqmnEinwllSTiOw5CCo,3473
-ocrd_utils/os.py,sha256=acRRdDBI8L6BK0Mf773yKEzwdpZSFRBJEKB2crL4EjU,9865
+ocrd_utils/os.py,sha256=EuxDV1mW6VRrtbUxAYb3G-teV9blICA-cXqbpzJjJfo,13564
 ocrd_utils/str.py,sha256=cRgqYILDGOAqWr0qrCrV52I3y4wvpwDVtnBGEUjXNS4,10116
 ocrd_validators/__init__.py,sha256=ZFc-UqRVBk9o1YesZFmr9lOepttNJ_NKx1Zdb7g_YsU,972
 ocrd_validators/bagit-profile.yml,sha256=sdQJlSi7TOn1E9WYMOZ1shewJ-i_nPaKmsAFkh28TGY,1011
@@ -106,7 +108,7 @@ ocrd_validators/message_processing.schema.yml,sha256=HL7o96-7ejslVMXcp16sbo5IjfU
 ocrd_validators/message_result.schema.yml,sha256=G6vt_JgIU7OGSaHj-2Jna6KWQ3bFWol5tnBArWEiVjM,681
 ocrd_validators/mets.xsd,sha256=0Wrs9bObn0n-yEEIWyguIcUUuuP6KMEjD4I_p1_UlwY,138290
 ocrd_validators/ocrd_network_message_validator.py,sha256=oafNWOjieBmTHFfYeCtyFFpW1gI0lDT6ycRr5Kvmfq0,561
-ocrd_validators/ocrd_tool.schema.yml,sha256=BQkRIRDbn9B8gFeVxz_EpNdleh_x2dCtIpJEC4HqFHw,10125
+ocrd_validators/ocrd_tool.schema.yml,sha256=fDNr-QdEOBtYbz8aHmjdOUirPBKr3vfLUDtC88gu75U,10231
 ocrd_validators/ocrd_tool_validator.py,sha256=CvfUHC0vJsPnmFBNf4ndQMXX6pcERCjJMAWk2L-T_ww,747
 ocrd_validators/ocrd_zip_validator.py,sha256=udAImFFliJY3y1FcKwZ52rhpjYB2Iv491hWDxdet8w0,3685
 ocrd_validators/page.xsd,sha256=abQ8C3gRLPMFm8lH62aTCfvTIWI23TpgEDcaW9YCt7I,85770
@@ -115,14 +117,14 @@ ocrd_validators/parameter_validator.py,sha256=_5Y3IS24Sf_xHBkB3TE3jB9VTCbbjWO8bS
 ocrd_validators/processing_server_config.schema.yml,sha256=8NQbhSshm1exTvbdYiu694rZZ-Xe70_vQtsJ0nd7ZCM,5432
 ocrd_validators/processing_server_config_validator.py,sha256=lQ2-ZxsvbFki_SvE_N4_1ptBnBHcwOTJ5grtL2G9F8A,810
 ocrd_validators/resource_list_validator.py,sha256=cFMj0n_x-tjhuNUpjgEvPP8iPVm7lme9TWAaqATasV0,776
-ocrd_validators/workspace_validator.py,sha256=rEXIwjtNpt8HcTv94fKed3vVlA3U4z7Xmm1ZL1VHC84,17892
+ocrd_validators/workspace_validator.py,sha256=JNPsRVPgQI0vsaxcs_c3qj22GagdZcgO3v9u3sbBbBI,20340
 ocrd_validators/xlink.xsd,sha256=8fW7YAMWXN2PbB_MMvj9H5ZeFoEBDzuYBtlGC8_6ijw,3180
 ocrd_validators/xsd_mets_validator.py,sha256=4GWfLyqkmca0x7osDuXuExYuM0HWVrKoqn0S35sFhHU,467
 ocrd_validators/xsd_page_validator.py,sha256=BNz_9u-Ek4UCeyZu3KxSQoolfW9lvuaSR9nIu1XXxeE,467
 ocrd_validators/xsd_validator.py,sha256=6HrVAf6SzCvfUIuQdIzz9bOq4V-zhyii9yrUPoK2Uvo,2094
-ocrd-3.1.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ocrd-3.1.1.dist-info/METADATA,sha256=athV-jzUTYFDjcbykQcSH6JXva7mNDVyHJgf3LCof8s,10442
-ocrd-3.1.1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-ocrd-3.1.1.dist-info/entry_points.txt,sha256=4hcJ2LkK_OlIabHnKgFit35Ap7b5Lz1Gb4hzkxV0Kiw,152
-ocrd-3.1.1.dist-info/top_level.txt,sha256=pUgiN42t4KXC5rvpi6V8atza31XP4SCznXpXlVlvomM,75
-ocrd-3.1.1.dist-info/RECORD,,
+ocrd-3.2.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ocrd-3.2.0.dist-info/METADATA,sha256=mOJkMaF0CIVwItP-6wrDIdRzZidf11AMcU5J_HubyxQ,10449
+ocrd-3.2.0.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+ocrd-3.2.0.dist-info/entry_points.txt,sha256=4hcJ2LkK_OlIabHnKgFit35Ap7b5Lz1Gb4hzkxV0Kiw,152
+ocrd-3.2.0.dist-info/top_level.txt,sha256=pUgiN42t4KXC5rvpi6V8atza31XP4SCznXpXlVlvomM,75
+ocrd-3.2.0.dist-info/RECORD,,

{ocrd-3.1.1.dist-info → ocrd-3.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (75.3.2)
 Root-Is-Purelib: true
 Tag: py3-none-any