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

ocrd/resource_manager.py

@@ -1,4 +1,3 @@
-from logging import Logger
 from pathlib import Path
 from os.path import join
 from os import environ, listdir, getcwd, unlink
@@ -6,7 +5,6 @@ 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
 
@@ -31,7 +29,6 @@ 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
 
@@ -50,10 +47,6 @@ 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():
@@ -62,12 +55,6 @@ 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:
@@ -82,22 +69,19 @@ class OcrdResourceManager:
 
     @property
     def xdg_config_home(self):
-        if not self._xdg_config_home:
-            self._xdg_config_home = config.XDG_CONFIG_HOME
-        return self._xdg_config_home
+        if self._xdg_config_home:
+            return self._xdg_config_home
+        return config.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: Path, database=None):
-        self.log.info(f"Loading resources from path: {list_filename}")
+    def load_resource_list(self, list_filename, database=None):
         if not database:
             database = self.database
         if list_filename.is_file():
@@ -114,36 +98,30 @@ class OcrdResourceManager:
                 database[executable] = list_loaded[executable] + database[executable]
         return database
 
-    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
-    ):
+    def list_available(self, executable=None, dynamic=True, name=None, database=None, url=None):
         """
         List models available for download by processor
         """
         if not database:
             database = self.database
         if not executable:
-            return list(database.items())
+            return database.items()
         if dynamic:
-            self._search_executables(executable)
-            self.save_user_list()
+            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)
         found = False
         ret = []
         for k in database:
@@ -161,7 +139,7 @@ class OcrdResourceManager:
             ret = [(executable, [])]
         return ret
 
-    def list_installed(self, executable: str = None):
+    def list_installed(self, executable=None):
         """
         List installed resources, matching with registry by ``name``
         """
@@ -172,24 +150,28 @@ class OcrdResourceManager:
             # resources we know about
             all_executables = list(self.database.keys())
             # resources in the file system
-            parent_dirs = [f"{join(self.xdg_data_home, 'ocrd-resources')}", RESOURCES_DIR_SYSTEM]
+            parent_dirs = [join(x, 'ocrd-resources') for x in [self.xdg_data_home, '/usr/local/share']]
             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)
-            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()
+            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
                 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)
-                if resdict := next((res for res in resdict_list if res['name'] == res_name), False):
-                    pass
-                elif str(res_filename.parent).startswith(moduledir):
+                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:
                     resdict = {
                         'name': res_name, 
                         'url': str(res_filename), 
@@ -199,28 +181,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 = res_filename.name
+        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}'")
         if Path(res_filename).is_dir():
             res_size = directory_size(res_filename)
         else:
             res_size = Path(res_filename).stat().st_size
-        user_database = self.load_resource_list(self.user_list)
+        with open(self.user_list, 'r', encoding='utf-8') as f:
+            user_database = safe_load(f) or {}
         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 '???',
@@ -240,45 +222,20 @@ class OcrdResourceManager:
     def default_resource_dir(self):
         return self.location_to_resource_dir('data')
 
-    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 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 resource_dir_to_location(self, resource_path: Path) -> str:
+    def resource_dir_to_location(self, resource_path):
         resource_path = str(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
+        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
 
     @staticmethod
-    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:
+    def parameter_usage(name, usage='as-is'):
         if usage == 'as-is':
             return name
         elif usage == 'without-extension':
@@ -286,7 +243,8 @@ class OcrdResourceManager:
         raise ValueError(f"No such usage '{usage}'")
 
     @staticmethod
-    def _download_impl(log: Logger, url: str, filename):
+    def _download_impl(url, filename, progress_cb=None, size=None):
+        log = getLogger('ocrd.resource_manager._download_impl')
         log.info(f"Downloading {url} to {filename}")
         try:
             gdrive_file_id, is_gdrive_download_link = gparse_url(url, warning=False)
@@ -298,11 +256,13 @@ class OcrdResourceManager:
                         if "Content-Disposition" not in r.headers:
                             url = get_url_from_gdrive_confirmation(r.text)
                 except RuntimeError as e:
-                    log.warning(f"Cannot unwrap Google Drive URL: {e}")
+                    log.warning("Cannot unwrap Google Drive URL: %s", 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)
@@ -310,18 +270,22 @@ class OcrdResourceManager:
             raise e
 
     @staticmethod
-    def _copy_file(log: Logger, src, dst):
+    def _copy_file(src, dst, progress_cb=None):
+        log = getLogger('ocrd.resource_manager._copy_file')
         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(log: Logger, src, dst):
+    def _copy_dir(src, dst, progress_cb=None):
+        log = getLogger('ocrd.resource_manager._copy_dir')
         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}")
@@ -329,123 +293,76 @@ class OcrdResourceManager:
         for child in Path(src).rglob('*'):
             child_dst = Path(dst) / child.relative_to(src)
             if Path(child).is_dir():
-                OcrdResourceManager._copy_dir(log, child, child_dst)
+                OcrdResourceManager._copy_dir(child, child_dst, progress_cb)
             else:
-                OcrdResourceManager._copy_file(log, child, child_dst)
+                OcrdResourceManager._copy_file(child, child_dst, progress_cb)
 
     @staticmethod
-    def _copy_impl(log: Logger, src_filename, filename):
+    def _copy_impl(src_filename, filename, progress_cb=None):
+        log = getLogger('ocrd.resource_manager._copy_impl')
         log.info(f"Copying {src_filename} to {filename}")
         if Path(src_filename).is_dir():
-            OcrdResourceManager._copy_dir(log, src_filename, filename)
+            OcrdResourceManager._copy_dir(src_filename, filename, progress_cb)
         else:
-            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
+            OcrdResourceManager._copy_file(src_filename, filename, progress_cb)
 
     # TODO Proper caching (make head request for size, If-Modified etc)
-    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]:
+    def download(
+        self, executable, url, basedir, overwrite=False, no_subdir=False, name=None, resource_type='file',
+        path_in_archive='.', progress_cb=None,
+    ):
         """
-        Download or Copy a resource by URL to a destination directory
+        Download a resource by URL
         """
-        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)
+        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://')
         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
-            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}")
+            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))
         return fpath
 
     def _dedup_database(self, database=None, dedup_key='name'):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ocrd
-Version: 3.2.0
+Version: 3.3.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>=7.1.0
+Requires-Dist: docker
 Requires-Dist: elementpath
 Requires-Dist: fastapi>=0.78.0
 Requires-Dist: filetype

{ocrd-3.2.0.dist-info → ocrd-3.3.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=CLwzUnk_uVOauyAPd0KhMjqBHmKNVluvS5QsK5O0m1A,20447
+ocrd/resource_manager.py,sha256=kIWDoKxWH4IJE1gcoTcCRQjYjieCqiQclyuyF6Y9b8A,16813
 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,10 +13,10 @@ 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=LNibNBtHGvtXuEwzFz1bLAfkroLWyMPsadTaNVwzUko,687
+ocrd/cli/network.py,sha256=oWBHFEURxfUdb_t-F4svP_ri7o5mqBoNQnLZLbsZLTA,602
 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=h9cSbp3_4sHkBqhWU7cThoUxcIqgrtD81st2nxZdnaw,8024
+ocrd/cli/resmgr.py,sha256=mk8KZweC_7ENAFnC6FvFf7Zv_W1wqJTmk0EMd9XSvf4,10132
 ocrd/cli/validate.py,sha256=nvageDaHCETcE71X5lu7i_4JKpgo9MrvJKinVPLYUTI,5727
 ocrd/cli/workspace.py,sha256=bsp6YXEgwABIUFbSENmxV1c4oxRwc2L-BpeDPlYfhHE,40501
 ocrd/cli/zip.py,sha256=MMJLw3OXWiJVfVtrdJcBkbB8vA1IzSautluazZRuCQ0,5910
@@ -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=tKN-xyPehFpwV3ztyLcOcuA_fWTNdRKu5E8V_jKOO2g,59400
+ocrd/processor/base.py,sha256=yN_sMfwm2B89wtr2ShNkEtcTjXNqnvAtjM4TbWTUNCk,59929
 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
@@ -48,28 +48,26 @@ 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=tLSOf5iTNSWjOWep_xY1sU2YZJu7uv9-3qLMuLrwyoU,433
+ocrd_network/__init__.py,sha256=gMejC614J5PPGgXDKBiQS0jt-Jx8qOrLbWH7zt8x8Gs,374
 ocrd_network/client.py,sha256=rzqtamZ8krRRy-QTO-AeWH8Lr3HhRiQe2R1-Lovd40g,3020
 ocrd_network/client_utils.py,sha256=VVZMNBgGznh41exZ78S48X3DDwHcWTuOq-LNdxjRvak,5002
-ocrd_network/constants.py,sha256=fxbC4QyeQp38KDRWjqnbfYjt3nUx6xT_mkmDt6PylyY,2033
+ocrd_network/constants.py,sha256=IeNtcU6dqonDE3Zw83_61auhS8X2b8wsjAxYg1zvK-M,1902
 ocrd_network/database.py,sha256=fcft7vdRDoR7vmPL1xNYTIeOg5DwRPcggwYDYxLy5ik,10706
-ocrd_network/logging_utils.py,sha256=mNYaLmKIf2Wg1gCU_FbicJC54mPhYPEVinmB7rHEdUs,2374
+ocrd_network/logging_utils.py,sha256=bO9TQqBXw9CIZEKp8tHXbeE2NuJWMiaQDHzS05b4ajo,2153
 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=YLt1LAcWrl1YfA_UsLYwWUGYsX84wCd1AZwgsUqjHC8,396
+ocrd_network/cli/__init__.py,sha256=F7YVqxw-9glz6-ghG0Kp5XXeV1-rL1emVSXLCWxdTF0,306
 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
@@ -87,18 +85,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=QkluX5aMCliE8YoH0rJcc9pNprx2Mw5l8_eOq5NJ74s,12319
-ocrd_network/runtime_data/network_agents.py,sha256=uJA6bB8O5XUvRc-wG4b4YKuArQOrQXKJMpMq1TC5bco,6289
+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/network_services.py,sha256=xrPpFUU_Pa-XzGe2FEt5RmO17xqykIUmTr_9g6S7XSs,7892
-ocrd_utils/__init__.py,sha256=mdLZyNz2W8t3ht8JMvbGaEfvQmYqXCWLBFcJXY6_fmA,6020
+ocrd_utils/__init__.py,sha256=U_zAQJwxg_aJ4CR84CKMNAUP6Cob8Er8Ikj42JmnUKo,5977
 ocrd_utils/config.py,sha256=1_8j4kpKK5gxhFKObbBEzmq4JazTtKEkGe14Ch_tpw0,11796
-ocrd_utils/constants.py,sha256=6lqMLeJdkFBlvGVmGjcExWbRKzNU6QT0kADBb5BkcBc,3464
+ocrd_utils/constants.py,sha256=ImbG1d8t2MW3uuFi-mN6aY90Zn74liAKZBKlfuKN86w,3278
 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=EuxDV1mW6VRrtbUxAYb3G-teV9blICA-cXqbpzJjJfo,13564
+ocrd_utils/os.py,sha256=acRRdDBI8L6BK0Mf773yKEzwdpZSFRBJEKB2crL4EjU,9865
 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
@@ -108,7 +106,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=fDNr-QdEOBtYbz8aHmjdOUirPBKr3vfLUDtC88gu75U,10231
+ocrd_validators/ocrd_tool.schema.yml,sha256=BQkRIRDbn9B8gFeVxz_EpNdleh_x2dCtIpJEC4HqFHw,10125
 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
@@ -122,9 +120,9 @@ ocrd_validators/xlink.xsd,sha256=8fW7YAMWXN2PbB_MMvj9H5ZeFoEBDzuYBtlGC8_6ijw,318
 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.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.3.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ocrd-3.3.0.dist-info/METADATA,sha256=K8u-P2RKlBlGPPq8h8sv5hLhWi0XgRmhF-Bf-F3Qgpc,10442
+ocrd-3.3.0.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+ocrd-3.3.0.dist-info/entry_points.txt,sha256=4hcJ2LkK_OlIabHnKgFit35Ap7b5Lz1Gb4hzkxV0Kiw,152
+ocrd-3.3.0.dist-info/top_level.txt,sha256=pUgiN42t4KXC5rvpi6V8atza31XP4SCznXpXlVlvomM,75
+ocrd-3.3.0.dist-info/RECORD,,

ocrd_network/__init__.py

@@ -4,5 +4,4 @@ from .processing_server import ProcessingServer
 from .processing_worker import ProcessingWorker
 from .processor_server import ProcessorServer
 from .param_validators import DatabaseParamType, ServerAddressParamType, QueueServerParamType
-from .resource_manager_server import ResourceManagerServer
 from .server_cache import CacheLockedPages, CacheProcessingRequests

ocrd_network/cli/__init__.py

@@ -2,12 +2,10 @@ from .client import client_cli
 from .processing_server import processing_server_cli
 from .processing_worker import processing_worker_cli
 from .processor_server import processor_server_cli
-from .resmgr_server import resource_manager_server_cli
 
 __all__ = [
     'client_cli',
     'processing_server_cli',
     'processing_worker_cli',
-    'processor_server_cli',
-    'resource_manager_server_cli'
+    'processor_server_cli'
 ]