ocrd 3.0.0a2__py3-none-any.whl → 3.0.0b1__py3-none-any.whl

ocrd/processor/base.py

@@ -9,6 +9,7 @@ __all__ = [
     'run_processor'
 ]
 
+from functools import cached_property
 from os.path import exists, join
 from shutil import copyfileobj
 import json
@@ -20,7 +21,8 @@ import sys
 import inspect
 import tarfile
 import io
-from warnings import warn
+import weakref
+from frozendict import frozendict
 from deprecated import deprecated
 from requests import HTTPError
 
@@ -33,18 +35,25 @@ from ocrd_utils import (
     MIME_TO_EXT,
     config,
     getLogger,
-    initLogging,
     list_resource_candidates,
     pushd_popd,
     list_all_resources,
     get_processor_resource_types,
     resource_filename,
-    resource_string,
+    parse_json_file_with_comments,
     make_file_id,
     deprecation_warning
 )
 from ocrd_validators import ParameterValidator
-from ocrd_models.ocrd_page import MetadataItemType, LabelType, LabelsType, OcrdPage, to_xml
+from ocrd_models.ocrd_page import (
+    PageType,
+    AlternativeImageType,
+    MetadataItemType,
+    LabelType,
+    LabelsType,
+    OcrdPage,
+    to_xml,
+)
 from ocrd_modelfactory import page_from_file
 from ocrd_validators.ocrd_tool_validator import OcrdToolValidator
 
@@ -94,54 +103,139 @@ class MissingInputFile(ValueError):
 
 class Processor():
     """
-    A processor is a tool that implements the uniform OCR-D command-line interface
-    for run-time data processing. That is, it executes a single workflow step,
-    or a combination of workflow steps, on the workspace (represented by local METS).
-    It reads input files for all or requested physical pages of the input fileGrp(s),
-    and writes output files for them into the output fileGrp(s). It may take 
-    a number of optional or mandatory parameters.
+    A processor is a tool that implements the uniform OCR-D
+    `command-line interface for run-time data processing <https://ocr-d.de/en/spec/cli>`_.
+
+    That is, it executes a single workflow step, or a combination of workflow steps,
+    on the workspace (represented by local METS). It reads input files for all or selected
+    physical pages of the input fileGrp(s), computes additional annotation, and writes output
+    files for them into the output fileGrp(s). It may take a number of optional or mandatory
+    parameters.
+    """
+
+    max_instances : int = -1
+    """
+    maximum number of cached instances (ignored if negative), to be applied on top of
+    :py:data:`~ocrd_utils.config.OCRD_MAX_PROCESSOR_CACHE` (i.e. whatever is smaller).
+
+    (Override this if you know how many instances fit into memory at once.)
     """
 
     @property
+    def metadata_filename(self) -> str:
+        """
+        Relative location of the ``ocrd-tool.json`` file inside the package.
+
+        Used by :py:data:`metadata_location`.
+
+        (Override if ``ocrd-tool.json`` is not in the root of the module,
+        e.g. ``namespace/ocrd-tool.json`` or ``data/ocrd-tool.json``).
+        """
+        return 'ocrd-tool.json'
+
+    @cached_property
+    def metadata_location(self) -> Path:
+        """
+        Absolute path of the ``ocrd-tool.json`` file as distributed with the package.
+
+        Used by :py:data:`metadata_rawdict`.
+
+        (Override if ``ocrd-tool.json`` is not distributed with the Python package.)
+        """
+        return resource_filename(self.__module__.split('.')[0], self.metadata_filename)
+
+    @cached_property
+    def metadata_rawdict(self) -> dict:
+        """
+        Raw (unvalidated, unexpanded) ``ocrd-tool.json`` dict contents of the package.
+
+        Used by :py:data:`metadata`.
+
+        (Override if ``ocrd-tool.json`` is not in a file.)
+        """
+        return parse_json_file_with_comments(self.metadata_location)
+
+    @cached_property
     def metadata(self) -> dict:
-        """the ocrd-tool.json dict of the package"""
-        if hasattr(self, '_metadata'):
-            return self._metadata
-        self._metadata = json.loads(resource_string(self.__module__.split('.')[0], 'ocrd-tool.json'))
-        report = OcrdToolValidator.validate(self._metadata)
+        """
+        The ``ocrd-tool.json`` dict contents of the package, according to the OCR-D
+        `spec <https://ocr-d.de/en/spec/ocrd_tool>`_ for processor tools.
+
+        After deserialisation, it also gets validated against the
+        `schema <https://ocr-d.de/en/spec/ocrd_tool#definition>`_ with all defaults
+        expanded.
+
+        Used by :py:data:`ocrd_tool` and :py:data:`version`.
+
+        (Override if you want to provide metadata programmatically instead of a
+        JSON file.)
+        """
+        metadata = self.metadata_rawdict
+        report = OcrdToolValidator.validate(metadata)
         if not report.is_valid:
-            # FIXME: remove when bertsky/core#10 is merged
-            self.logger = getLogger(f'ocrd.processor.{self.__class__.__name__}')
-            self.logger.error(f"The ocrd-tool.json of this processor is {'problematic' if not report.errors else 'invalid'}:\n{report.to_xml()}.\nPlease open an issue at {self._metadata['git_url']}.")
-        return self._metadata
+            self.logger.error(f"The ocrd-tool.json of this processor is {'problematic' if not report.errors else 'invalid'}:\n"
+                              f"{report.to_xml()}.\nPlease open an issue at {metadata.get('git_url', 'the website')}.")
+        return metadata
 
-    @property
+    @cached_property
     def version(self) -> str:
-        """the version of the package"""
-        if hasattr(self, '_version'):
-            return self._version
-        self._version = self.metadata['version']
-        return self._version
+        """
+        The program version of the package.
+        Usually the ``version`` part of :py:data:`metadata`.
 
-    @property
+        (Override if you do not want to use :py:data:`metadata` lookup
+        mechanism.)
+        """
+        return self.metadata['version']
+
+    @cached_property
     def executable(self) -> str:
-        """the executable name of this processor tool"""
-        if hasattr(self, '_executable'):
-            return self._executable
-        self._executable = os.path.basename(inspect.stack()[-1].filename)
-        return self._executable
+        """
+        The executable name of this processor tool. Taken from the runtime
+        filename.
 
-    @property
+        Used by :py:data:`ocrd_tool` for lookup in :py:data:`metadata`.
+
+        (Override if your entry-point name deviates from the ``executable``
+        name, or the processor gets instantiated from another runtime.)
+        """
+        return os.path.basename(inspect.stack()[-1].filename)
+
+    @cached_property
     def ocrd_tool(self) -> dict:
-        """the ocrd-tool.json dict of this processor tool"""
-        if hasattr(self, '_ocrd_tool'):
-            return self._ocrd_tool
-        self._ocrd_tool = self.metadata['tools'][self.executable]
-        return self._ocrd_tool
+        """
+        The ``ocrd-tool.json`` dict contents of this processor tool.
+        Usually the :py:data:`executable` key of the ``tools`` part
+        of :py:data:`metadata`.
+
+        (Override if you do not want to use :py:data:`metadata` lookup
+        mechanism.)
+        """
+        return self.metadata['tools'][self.executable]
+
+    @property
+    def parameter(self) -> Optional[dict]:
+        """the runtime parameter dict to be used by this processor"""
+        if hasattr(self, '_parameter'):
+            return self._parameter
+        return None
+
+    @parameter.setter
+    def parameter(self, parameter : dict) -> None:
+        if self.parameter is not None:
+            self.shutdown()
+        parameterValidator = ParameterValidator(self.ocrd_tool)
+        report = parameterValidator.validate(parameter)
+        if not report.is_valid:
+            raise ValueError(f'Invalid parameters:\n{report.to_xml()}')
+        # make parameter dict read-only
+        self._parameter = frozendict(parameter)
+        # (re-)run setup to load models etc
+        self.setup()
 
     def __init__(
             self,
-            # FIXME: deprecate in favor of process_workspace(workspace)
+            # FIXME: remove in favor of process_workspace(workspace)
             workspace : Optional[Workspace],
             ocrd_tool=None,
             parameter=None,
@@ -204,19 +298,14 @@ class Processor():
                                 "is deprecated - pass as argument to process_workspace instead")
             self.page_id = page_id or None
         self.download = download_files
-        if parameter is None:
-            parameter = {}
-        parameterValidator = ParameterValidator(self.ocrd_tool)
-
-        report = parameterValidator.validate(parameter)
-        if not report.is_valid:
-            raise ValueError("Invalid parameters %s" % report.errors)
-        self.parameter = parameter
-        # NOTE: this is the logger to be used by processor implementations,
-        # `processor.base` default implementations should use
-        # :py:attr:`self._base_logger`
+        #: The logger to be used by processor implementations.
+        # `ocrd.processor.base` internals should use :py:attr:`self._base_logger`
         self.logger = getLogger(f'ocrd.processor.{self.__class__.__name__}')
         self._base_logger = getLogger('ocrd.processor.base')
+        if parameter is not None:
+            self.parameter = parameter
+        # ensure that shutdown gets called at destruction
+        self._finalizer = weakref.finalize(self, self.shutdown)
         # workaround for deprecated#72 (@deprecated decorator does not work for subclasses):
         setattr(self, 'process',
                 deprecated(version='3.0', reason='process() should be replaced with process_page() and process_workspace()')(getattr(self, 'process')))
@@ -254,14 +343,10 @@ class Processor():
                     assert len(grps) >= minimum, msg % (len(grps), str(spec))
                 if maximum > 0:
                     assert len(grps) <= maximum, msg % (len(grps), str(spec))
-        # FIXME: maybe we should enforce the cardinality properties to be specified or apply default=1 here
-        # (but we already have ocrd-tool validation, and these first need to be adopted by implementors)
-        if 'input_file_grp_cardinality' in self.ocrd_tool:
-            assert_file_grp_cardinality(input_file_grps, self.ocrd_tool['input_file_grp_cardinality'],
-                                        "Unexpected number of input file groups %d vs %s")
-        if 'output_file_grp_cardinality' in self.ocrd_tool:
-            assert_file_grp_cardinality(output_file_grps, self.ocrd_tool['output_file_grp_cardinality'],
-                                        "Unexpected number of output file groups %d vs %s")
+        assert_file_grp_cardinality(input_file_grps, self.ocrd_tool['input_file_grp_cardinality'],
+                                    "Unexpected number of input file groups %d vs %s")
+        assert_file_grp_cardinality(output_file_grps, self.ocrd_tool['output_file_grp_cardinality'],
+                                    "Unexpected number of output file groups %d vs %s")
         for input_file_grp in input_file_grps:
             assert input_file_grp in self.workspace.mets.file_groups
         # keep this for backwards compatibility:
@@ -272,14 +357,12 @@ class Processor():
         Print :py:attr:`ocrd_tool` on stdout.
         """
         print(json.dumps(self.ocrd_tool, indent=True))
-        return
 
     def dump_module_dir(self):
         """
         Print :py:attr:`moduledir` on stdout.
         """
         print(self.moduledir)
-        return
 
     def list_resources(self):
         """
@@ -287,7 +370,6 @@ class Processor():
         """
         for res in self.list_all_resources():
             print(res)
-        return
 
     def setup(self) -> None:
         """
@@ -299,6 +381,16 @@ class Processor():
         """
         pass
 
+    def shutdown(self) -> None:
+        """
+        Bring down the processor after data processing,
+        after to changing back from the workspace directory but
+        before exiting (or setting up with different parameters).
+
+        (Override this to unload models from memory etc.)
+        """
+        pass
+
     @deprecated(version='3.0', reason='process() should be replaced with process_page_pcgts() or process_page_file() or process_workspace()')
     def process(self) -> None:
         """
@@ -439,7 +531,15 @@ class Processor():
         for image_result in result.images:
             image_file_id = f'{output_file_id}_{image_result.file_id_suffix}'
             image_file_path = join(self.output_file_grp, f'{image_file_id}.png')
-            image_result.alternative_image.set_filename(image_file_path)
+            if isinstance(image_result.alternative_image, PageType):
+                image_result.alternative_image.set_imageFilename(image_file_path)
+                image_result.alternative_image.set_imageWidth(image_result.pil.width)
+                image_result.alternative_image.set_imageHeight(image_result.pil.height)
+            elif isinstance(image_result.alternative_image, AlternativeImageType):
+                image_result.alternative_image.set_filename(image_file_path)
+            else:
+                raise ValueError(f"process_page_pcgts returned an OcrdPageResultImage of unknown type "
+                                 f"{type(image_result.alternative_image)}")
             self.workspace.save_image_file(
                 image_result.pil,
                 image_file_id,
@@ -668,7 +768,7 @@ class Processor():
         # can actually be much more costly than traversing the ltree.
         # This might depend on the number of pages vs number of fileGrps.
 
-        pages = dict()
+        pages = {}
         for i, ifg in enumerate(ifgs):
             files_ = sorted(self.workspace.mets.find_all_files(
                     pageId=self.page_id, fileGrp=ifg, mimetype=mimetype),
@@ -723,7 +823,7 @@ class Processor():
         if self.page_id and not any(pages):
             self._base_logger.critical(f"Could not find any files for selected pageId {self.page_id}.\n"
                                        f"compare '{self.page_id}' with the output of 'orcd workspace list-page'.")
-        ifts = list()
+        ifts = []
         for page, ifiles in pages.items():
             for i, ifg in enumerate(ifgs):
                 if not ifiles[i]:

ocrd/processor/builtin/dummy_processor.py

@@ -1,6 +1,6 @@
 # pylint: disable=missing-module-docstring,invalid-name
-from os.path import join, basename
-from typing import Optional, Union
+from os.path import join
+from typing import Optional
 
 import click
 
@@ -10,7 +10,6 @@ from ocrd.processor.ocrd_page_result import OcrdPageResult
 from ocrd_models.ocrd_file import OcrdFileType
 from ocrd_models.ocrd_page import OcrdPage, to_xml
 from ocrd_utils import (
-    getLogger,
     make_file_id,
     MIME_TO_EXT,
     MIMETYPE_PAGE,
@@ -20,8 +19,6 @@ from ocrd_utils import (
 )
 from ocrd_modelfactory import page_from_file
 
-OCRD_TOOL = parse_json_string_with_comments(resource_string(__package__ + '.dummy', 'ocrd-tool.json'))
-
 class DummyProcessor(Processor):
     """
     Bare-bones processor creates PAGE-XML and optionally copies file from input group to output group
@@ -76,17 +73,13 @@ class DummyProcessor(Processor):
             super().process_page_file(input_file)
 
     @property
-    def metadata(self):
-        return OCRD_TOOL
+    def metadata_filename(self):
+        return 'processor/builtin/dummy/ocrd-tool.json'
 
     @property
     def executable(self):
         return 'ocrd-dummy'
 
-    @property
-    def version(self):
-        return '0.0.3'
-
 @click.command()
 @ocrd_cli_options
 def cli(*args, **kwargs):

ocrd/processor/helpers.py

@@ -1,13 +1,12 @@
 """
 Helper methods for running and documenting processors
 """
-from os import chdir, getcwd
 from time import perf_counter, process_time
 from functools import lru_cache
 import json
 import inspect
 from subprocess import run
-from typing import List
+from typing import List, Optional
 
 from click import wrap_text
 from ocrd.workspace import Workspace
@@ -39,10 +38,7 @@ def run_processor(
         log_level=None,
         input_file_grp=None,
         output_file_grp=None,
-        show_resource=None,
-        list_resources=False,
         parameter=None,
-        parameter_override=None,
         working_dir=None,
         mets_server_url=None,
         instance_caching=False
@@ -84,7 +80,7 @@ def run_processor(
     log.debug("Running processor %s", processorClass)
 
     processor = get_processor(
-        processor_class=processorClass,
+        processorClass,
         parameter=parameter,
         workspace=None,
         page_id=page_id,
@@ -102,7 +98,7 @@ def run_processor(
     t0_cpu = process_time()
     if any(x in config.OCRD_PROFILE for x in ['RSS', 'PSS']):
         backend = 'psutil_pss' if 'PSS' in config.OCRD_PROFILE else 'psutil'
-        from memory_profiler import memory_usage
+        from memory_profiler import memory_usage # pylint: disable=import-outside-toplevel
         try:
             mem_usage = memory_usage(proc=(processor.process_workspace, [workspace], {}),
                                      # only run process once
@@ -212,7 +208,7 @@ def run_cli(
     if not log_filename:
         result = run(args, check=False)
     else:
-        with open(log_filename, 'a') as file_desc:
+        with open(log_filename, 'a', encoding='utf-8') as file_desc:
             result = run(args, check=False, stdout=file_desc, stderr=file_desc)
     return result.returncode
 
@@ -359,9 +355,9 @@ Options:
         pass
 
 
-# Taken from https://github.com/OCR-D/core/pull/884
-@freeze_args
-@lru_cache(maxsize=config.OCRD_MAX_PROCESSOR_CACHE)
+# not decorated here but at runtime (on first use)
+#@freeze_args
+#@lru_cache(maxsize=config.OCRD_MAX_PROCESSOR_CACHE)
 def get_cached_processor(parameter: dict, processor_class):
     """
     Call this function to get back an instance of a processor.
@@ -374,16 +370,13 @@ def get_cached_processor(parameter: dict, processor_class):
         Otherwise, an instance of the `:py:class:~ocrd.Processor` is returned.
     """
     if processor_class:
-        dict_params = dict(parameter) if parameter else None
-        processor = processor_class(None, parameter=dict_params)
-        processor.setup()
+        processor = processor_class(None, parameter=dict(parameter))
         return processor
     return None
 
-
 def get_processor(
         processor_class,
-        parameter: dict,
+        parameter: Optional[dict] = None,
         workspace: Workspace = None,
         page_id: str = None,
         input_file_grp: List[str] = None,
@@ -391,11 +384,24 @@ def get_processor(
         instance_caching: bool = False,
 ):
     if processor_class:
+        if parameter is None:
+            parameter = {}
         if instance_caching:
+            global get_cached_processor
+            if not hasattr(get_cached_processor, '__wrapped__'):
+                # first call: wrap
+                if processor_class.max_instances < 0:
+                    maxsize = config.OCRD_MAX_PROCESSOR_CACHE
+                else:
+                    maxsize = min(config.OCRD_MAX_PROCESSOR_CACHE, processor_class.max_instances)
+                # wrapping in call cache
+                # wrapping dict into frozendict (from https://github.com/OCR-D/core/pull/884)
+                get_cached_processor = freeze_args(lru_cache(maxsize=maxsize)(get_cached_processor))
             processor = get_cached_processor(parameter, processor_class)
         else:
+            # avoid passing workspace already (deprecated chdir behaviour)
             processor = processor_class(None, parameter=parameter)
-            processor.setup()
+        # set current processing parameters
         processor.workspace = workspace
         processor.page_id = page_id
         processor.input_file_grp = input_file_grp

ocrd/processor/ocrd_page_result.py

@@ -1,15 +1,15 @@
 from dataclasses import dataclass, field
-from typing import List
+from typing import List, Union
 from ocrd_models.ocrd_page import OcrdPage
 from PIL.Image import Image
 
-from ocrd_models.ocrd_page_generateds import AlternativeImageType
+from ocrd_models.ocrd_page_generateds import AlternativeImageType, PageType
 
 @dataclass
 class OcrdPageResultImage():
     pil : Image
     file_id_suffix : str
-    alternative_image : AlternativeImageType
+    alternative_image : Union[AlternativeImageType, PageType]
 
 @dataclass
 class OcrdPageResult():

ocrd/resolver.py

@@ -18,7 +18,6 @@ from ocrd_utils import (
 )
 from ocrd.workspace import Workspace
 from ocrd_models import OcrdMets
-from ocrd_models.constants import NAMESPACES as NS
 from ocrd_models.utils import handle_oai_response
 
 class Resolver():
@@ -310,5 +309,3 @@ class Resolver():
                         raise ValueError("--mets '%s' has a directory part inconsistent with --directory '%s'" % (mets_url, directory))
 
         return str(Path(directory).resolve()), str(mets_url), str(mets_basename), mets_server_url
-
-

ocrd/resource_manager.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 from os.path import join
-from os import environ, listdir, makedirs, getcwd, path, unlink
+from os import environ, listdir, getcwd, unlink
 from shutil import copytree, rmtree, copy
 from fnmatch import filter as apply_glob
 from datetime import datetime
@@ -13,14 +13,18 @@ from gdown.parse_url import parse_url as gparse_url
 from gdown.download import get_url_from_gdrive_confirmation
 from yaml import safe_load, safe_dump
 
+# pylint: disable=wrong-import-position
+
 # https://github.com/OCR-D/core/issues/867
 # https://stackoverflow.com/questions/50900727/skip-converting-entities-while-loading-a-yaml-string-using-pyyaml
 import yaml.constructor
-yaml.constructor.SafeConstructor.yaml_constructors[u'tag:yaml.org,2002:timestamp'] = \
-    yaml.constructor.SafeConstructor.yaml_constructors[u'tag:yaml.org,2002:str']
+yaml.constructor.SafeConstructor.yaml_constructors['tag:yaml.org,2002:timestamp'] = \
+    yaml.constructor.SafeConstructor.yaml_constructors['tag:yaml.org,2002:str']
+
+# pylint: enable=wrong-import-position
 
 from ocrd_validators import OcrdResourceListValidator
-from ocrd_utils import getLogger, directory_size, get_moduledir, EXT_TO_MIME, nth_url_segment, guess_media_type, config
+from ocrd_utils import getLogger, directory_size, get_moduledir, guess_media_type, config
 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
 
@@ -248,7 +252,7 @@ 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: ", 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()

ocrd/workspace.py

@@ -1,7 +1,7 @@
 import io
 from os import makedirs, unlink, listdir, path
 from pathlib import Path
-from shutil import move, copyfileobj
+from shutil import copyfileobj
 from re import sub
 from tempfile import NamedTemporaryFile
 from contextlib import contextmanager
@@ -43,7 +43,6 @@ from ocrd_utils import (
     MIME_TO_PIL,
     MIMETYPE_PAGE,
     REGEX_PREFIX,
-    config
 )
 
 from .workspace_backup import WorkspaceBackupManager
@@ -111,7 +110,7 @@ class Workspace():
 
     def __repr__(self):
         return 'Workspace[remote=%s, directory=%s, baseurl=%s, file_groups=%s, files=%s]' % (
-            not not self.is_remote,
+            self.is_remote,
             self.directory,
             self.baseurl,
             self.mets.file_groups,
@@ -648,7 +647,7 @@ class Workspace():
         log = getLogger('ocrd.workspace.image_from_page')
         page_image_info = self.resolve_image_exif(page.imageFilename)
         page_image = self._resolve_image_as_pil(page.imageFilename)
-        page_coords = dict()
+        page_coords = {}
         # use identity as initial affine coordinate transform:
         page_coords['transform'] = np.eye(3)
         # interim bbox (updated with each change to the transform):
@@ -1091,7 +1090,7 @@ class Workspace():
             The (absolute) path of the created file.
         """
         log = getLogger('ocrd.workspace.save_image_file')
-        saveargs = dict()
+        saveargs = {}
         if 'dpi' in image.info:
             saveargs['dpi'] = image.info['dpi']
         image_bytes = io.BytesIO()
@@ -1168,9 +1167,9 @@ def _reflect(log, name, orientation, segment_image, segment_coords, segment_xywh
     # Transpose in affine coordinate transform:
     # (consistent with image transposition or AlternativeImage below)
     transposition = {
-        90: Image.ROTATE_90,
-        180: Image.ROTATE_180,
-        270: Image.ROTATE_270
+        90: Image.Transpose.ROTATE_90,
+        180: Image.Transpose.ROTATE_180,
+        270: Image.Transpose.ROTATE_270
     }.get(orientation) # no default
     segment_coords['transform'] = transpose_coordinates(
         segment_coords['transform'], transposition,
@@ -1238,5 +1237,5 @@ def _scale(log, name, factor, segment_image, segment_coords, segment_xywh, **kwa
         segment_image = segment_image.resize((int(segment_image.width * factor),
                                               int(segment_image.height * factor)),
                                              # slowest, but highest quality:
-                                             Image.BICUBIC)
+                                             Image.Resampling.BICUBIC)
     return segment_image, segment_coords, segment_xywh

ocrd/workspace_backup.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 from os import makedirs
-from os.path import join, basename, getsize, abspath
+from os.path import join, basename, getsize
 from glob import glob
 from shutil import copy
 import hashlib

{ocrd-3.0.0a2.dist-info → ocrd-3.0.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ocrd
-Version: 3.0.0a2
+Version: 3.0.0b1
 Summary: OCR-D framework
 Author-email: Konstantin Baierer <unixprog@gmail.com>
 License: Apache License 2.0