ocrd 3.5.0__py3-none-any.whl → 3.6.0__py3-none-any.whl

ocrd_utils/image.py

@@ -39,14 +39,15 @@ __all__ = [
     'xywh_from_polygon',
 ]
 
+
 def adjust_canvas_to_rotation(size, angle):
     """Calculate the enlarged image size after rotation.
-    
+
     Given a numpy array ``size`` of an original canvas (width and height),
     and a rotation angle in degrees counter-clockwise ``angle``,
     calculate the new size which is necessary to encompass the full
     image after rotation.
-    
+
     Return a numpy array of the enlarged width and height.
     """
     angle = np.deg2rad(angle)
@@ -56,13 +57,14 @@ def adjust_canvas_to_rotation(size, angle):
                             [sin, cos]]),
                   np.array(size))
 
+
 def adjust_canvas_to_transposition(size, method):
     """Calculate the flipped image size after transposition.
-    
+
     Given a numpy array ``size`` of an original canvas (width and height),
     and a transposition mode ``method`` (see ``transpose_image``),
     calculate the new size after transposition.
-    
+
     Return a numpy array of the enlarged width and height.
     """
     if method in [Image.Transpose.ROTATE_90,
@@ -72,11 +74,13 @@ def adjust_canvas_to_transposition(size, method):
         size = size[::-1]
     return size
 
+
 def bbox_from_points(points):
     """Construct a numeric list representing a bounding box from polygon coordinates in page representation."""
     xys = [[int(p) for p in pair.split(',')] for pair in points.split(' ')]
     return bbox_from_polygon(xys)
 
+
 def bbox_from_polygon(polygon):
     """Construct a numeric list representing a bounding box from polygon coordinates in numeric list representation."""
     minx = sys.maxsize
@@ -94,6 +98,7 @@ def bbox_from_polygon(polygon):
             maxy = xy[1]
     return minx, miny, maxx, maxy
 
+
 def bbox_from_xywh(xywh):
     """Convert a bounding box from a numeric dict to a numeric list representation."""
     return (
@@ -103,23 +108,24 @@ def bbox_from_xywh(xywh):
         xywh['y'] + xywh['h']
     )
 
+
 def coordinates_of_segment(segment, parent_image, parent_coords):
     """Extract the coordinates of a PAGE segment element relative to its parent.
 
+    \b
     Given...
-
     - ``segment``, a PAGE segment object in absolute coordinates
       (i.e. RegionType / TextLineType / WordType / GlyphType), and
     - ``parent_image``, the PIL.Image of its corresponding parent object
       (i.e. PageType / RegionType / TextLineType / WordType), (not used),
       along with
     - ``parent_coords``, its corresponding affine transformation,
-
     ...calculate the relative coordinates of the segment within the image.
 
     That is, apply the given transform to the points annotated in ``segment``.
     The transform encodes (recursively):
 
+    \b
     1. Whenever ``parent_image`` or any of its parents was cropped,
        all points must be shifted by the offset
        (i.e. coordinate system gets translated by the upper left).
@@ -138,6 +144,7 @@ def coordinates_of_segment(segment, parent_image, parent_coords):
     polygon = transform_coordinates(polygon, parent_coords['transform'])
     return np.round(polygon).astype(np.int32)
 
+
 def polygon_from_points(points):
     """
     Convert polygon coordinates in page representation to polygon coordinates in numeric list representation.
@@ -152,17 +159,17 @@ def polygon_from_points(points):
 def coordinates_for_segment(polygon, parent_image, parent_coords):
     """Convert relative coordinates to absolute.
 
+    \b
     Given...
-
     - ``polygon``, a numpy array of points relative to
     - ``parent_image``, a PIL.Image (not used), along with
     - ``parent_coords``, its corresponding affine transformation,
-
     ...calculate the absolute coordinates within the page.
-    
+
     That is, apply the given transform inversely to ``polygon``
     The transform encodes (recursively):
 
+    \b
     1. Whenever ``parent_image`` or any of its parents was cropped,
        all points must be shifted by the offset in opposite direction
        (i.e. coordinate system gets translated by the upper left).
@@ -176,12 +183,13 @@ def coordinates_for_segment(polygon, parent_image, parent_coords):
 
     Return the rounded numpy array of the resulting polygon.
     """
-    polygon = np.array(polygon, dtype=np.float32) # avoid implicit type cast problems
+    polygon = np.array(polygon, dtype=np.float32)  # avoid implicit type cast problems
     # apply inverse of affine transform:
     inv_transform = np.linalg.inv(parent_coords['transform'])
     polygon = transform_coordinates(polygon, inv_transform)
     return np.round(polygon).astype(np.int32)
 
+
 def polygon_mask(image, coordinates):
     """"Create a mask image of a polygon.
 
@@ -197,6 +205,7 @@ def polygon_mask(image, coordinates):
     ImageDraw.Draw(mask).polygon(coordinates, outline=0, fill=255)
     return mask
 
+
 def rotate_coordinates(transform, angle, orig=np.array([0, 0])):
     """Compose an affine coordinate transformation with a passive rotation.
 
@@ -209,7 +218,7 @@ def rotate_coordinates(transform, angle, orig=np.array([0, 0])):
     by pure rotation, and subsequent translation back. However, since
     rotation necessarily increases the bounding box, and thus image size,
     do not translate back the same amount, but to the enlarged offset.)
-    
+
     Return a numpy array of the resulting affine transformation matrix.
     """
     LOG = getLogger('ocrd.utils.coords.rotate_coordinates')
@@ -234,6 +243,7 @@ def rotate_coordinates(transform, angle, orig=np.array([0, 0])):
         adjust_canvas_to_rotation(orig, angle))
     return transform
 
+
 def rotate_image(image, angle, fill='background', transparency=False):
     """"Rotate an image, enlarging and filling with background.
 
@@ -242,6 +252,7 @@ def rotate_image(image, angle, fill='background', transparency=False):
     size at the margins accordingly, and filling everything outside
     the original image according to ``fill``:
 
+    \b
     - if ``background`` (the default),
       then use the median color of the image;
     - otherwise use the given color, e.g. ``'white'`` or (255,255,255).
@@ -267,7 +278,7 @@ def rotate_image(image, angle, fill='background', transparency=False):
         if len(background.bands) > 1:
             background = background.median
             if image.mode in ['RGBA', 'LA']:
-                background[-1] = 0 # fully transparent
+                background[-1] = 0  # fully transparent
             background = tuple(background)
         else:
             background = background.median[0]
@@ -295,7 +306,7 @@ def shift_coordinates(transform, offset):
     ``offset`` of the translation vector, calculate the affine
     coordinate transform corresponding to the composition of both
     transformations.
-    
+
     Return a numpy array of the resulting affine transformation matrix.
     """
     LOG = getLogger('ocrd.utils.coords.shift_coordinates')
@@ -305,6 +316,7 @@ def shift_coordinates(transform, offset):
     shift[1, 2] = offset[1]
     return np.dot(shift, transform)
 
+
 def scale_coordinates(transform, factors):
     """Compose an affine coordinate transformation with a proportional scaling.
     Given a numpy array ``transform`` of an existing transformation
@@ -312,7 +324,7 @@ def scale_coordinates(transform, factors):
     ``factors`` of the scaling factors, calculate the affine
     coordinate transform corresponding to the composition of both
     transformations.
-    
+
     Return a numpy array of the resulting affine transformation matrix.
     """
     LOG = getLogger('ocrd.utils.coords.scale_coordinates')
@@ -322,6 +334,7 @@ def scale_coordinates(transform, factors):
     scale[1, 1] = factors[1]
     return np.dot(scale, transform)
 
+
 def transform_coordinates(polygon, transform=None):
     """Apply an affine transformation to a set of points.
     Augment the 2d numpy array of points ``polygon`` with a an extra
@@ -331,23 +344,24 @@ def transform_coordinates(polygon, transform=None):
     """
     if transform is None:
         transform = np.eye(3)
-    polygon = np.insert(polygon, 2, 1, axis=1) # make 3d homogeneous coordinates
+    polygon = np.insert(polygon, 2, 1, axis=1)  # make 3d homogeneous coordinates
     polygon = np.dot(transform, polygon.T).T
     # ones = polygon[:,2]
     # assert np.all(np.array_equal(ones, np.clip(ones, 1 - 1e-2, 1 + 1e-2))), \
     #     'affine transform failed' # should never happen
-    polygon = np.delete(polygon, 2, axis=1) # remove z coordinate again
+    polygon = np.delete(polygon, 2, axis=1)  # remove z coordinate again
     return polygon
 
+
 def transpose_coordinates(transform, method, orig=np.array([0, 0])):
     """"Compose an affine coordinate transformation with a transposition (i.e. flip or rotate in 90° multiples).
 
+    \b
     Given a numpy array ``transform`` of an existing transformation
     matrix in homogeneous (3d) coordinates, a transposition mode ``method``,
     as well as a numpy array ``orig`` of the center of the image,
     calculate the affine coordinate transform corresponding to the composition
     of both transformations, which is respectively:
-
     - ``PIL.Image.Transpose.FLIP_LEFT_RIGHT``:
       entails translation to the center, followed by pure reflection
       about the y-axis, and subsequent translation back
@@ -395,7 +409,7 @@ def transpose_coordinates(transform, method, orig=np.array([0, 0])):
         Image.Transpose.ROTATE_270: [rot90, reflx, refly],
         Image.Transpose.TRANSPOSE: [rot90, reflx],
         Image.Transpose.TRANSVERSE: [rot90, refly]
-    }.get(method) # no default
+    }.get(method)  # no default
     for operation in operations:
         transform = np.dot(operation, transform)
     transform = shift_coordinates(
@@ -405,12 +419,13 @@ def transpose_coordinates(transform, method, orig=np.array([0, 0])):
         adjust_canvas_to_transposition(orig, method))
     return transform
 
+
 def transpose_image(image, method):
     """"Transpose (i.e. flip or rotate in 90° multiples) an image.
 
+    \b
     Given a PIL.Image ``image`` and a transposition mode ``method``,
     apply the respective operation:
-
     - ``PIL.Image.Transpose.FLIP_LEFT_RIGHT``:
       all pixels get mirrored at half the width of the image
     - ``PIL.Image.Transpose.FLIP_TOP_BOTTOM``:
@@ -438,13 +453,14 @@ def transpose_image(image, method):
       columns become rows (but counted from the bottom),
       i.e. all pixels get mirrored at the opposite diagonal;
       width becomes height and vice versa
-    
+
     Return a new PIL.Image.
     """
     LOG = getLogger('ocrd.utils.transpose_image')
     LOG.debug('transposing image with %s', membername(Image, method))
     return image.transpose(method)
 
+
 def crop_image(image, box=None):
     """"Crop an image to a rectangle, filling with background.
 
@@ -475,10 +491,11 @@ def crop_image(image, box=None):
     else:
         background = background.median[0]
     new_image = Image.new(image.mode, (xywh['w'], xywh['h']),
-                          background) # or 'white'
+                          background)  # or 'white'
     new_image.paste(image, (-xywh['x'], -xywh['y']))
     return new_image
 
+
 def image_from_polygon(image, polygon, fill='background', transparency=False):
     """"Mask an image with a polygon.
 
@@ -497,7 +514,7 @@ def image_from_polygon(image, polygon, fill='background', transparency=False):
     Images which already have an alpha channel will have it shrunk
     from the polygon mask (i.e. everything outside the polygon will
     be transparent, in addition to existing transparent pixels).
-    
+
     Return a new PIL.Image.
     """
     if fill == 'none' or fill is None:
@@ -521,22 +538,25 @@ def image_from_polygon(image, polygon, fill='background', transparency=False):
     #  which can be inconsistent on unbinarized images):
     if image.mode in ['RGBA', 'LA']:
         # ensure transparency maximizes (i.e. parent mask AND mask):
-        mask = ImageChops.darker(mask, image.getchannel('A')) # min opaque
+        mask = ImageChops.darker(mask, image.getchannel('A'))  # min opaque
         new_image.putalpha(mask)
     elif transparency and image.mode in ['RGB', 'L']:
         # introduce transparency:
         new_image.putalpha(mask)
     return new_image
 
+
 def points_from_bbox(minx, miny, maxx, maxy):
     """Construct polygon coordinates in page representation from a numeric list representing a bounding box."""
     return "%i,%i %i,%i %i,%i %i,%i" % (
         minx, miny, maxx, miny, maxx, maxy, minx, maxy)
 
+
 def points_from_polygon(polygon):
     """Convert polygon coordinates from a numeric list representation to a page representation."""
     return " ".join("%i,%i" % (x, y) for x, y in polygon)
 
+
 def points_from_xywh(box):
     """
     Construct polygon coordinates in page representation from numeric dict representing a bounding box.
@@ -549,6 +569,8 @@ def points_from_xywh(box):
         x + w, y + h,
         x, y + h
     )
+
+
 def points_from_y0x0y1x1(yxyx):
     """
     Construct a polygon representation from a rectangle described as a list [y0, x0, y1, x1]
@@ -564,6 +586,7 @@ def points_from_y0x0y1x1(yxyx):
         x0, y1
     )
 
+
 def points_from_x0y0x1y1(xyxy):
     """
     Construct a polygon representation from a rectangle described as a list [x0, y0, x1, y1]
@@ -579,10 +602,12 @@ def points_from_x0y0x1y1(xyxy):
         x0, y1
     )
 
+
 def polygon_from_bbox(minx, miny, maxx, maxy):
     """Construct polygon coordinates in numeric list representation from a numeric list representing a bounding box."""
     return [[minx, miny], [maxx, miny], [maxx, maxy], [minx, maxy]]
 
+
 def polygon_from_x0y0x1y1(x0y0x1y1):
     """Construct polygon coordinates in numeric list representation from a string list representing a bounding box."""
     minx = int(x0y0x1y1[0])
@@ -591,10 +616,12 @@ def polygon_from_x0y0x1y1(x0y0x1y1):
     maxy = int(x0y0x1y1[3])
     return [[minx, miny], [maxx, miny], [maxx, maxy], [minx, maxy]]
 
+
 def polygon_from_xywh(xywh):
     """Construct polygon coordinates in numeric list representation from numeric dict representing a bounding box."""
     return polygon_from_bbox(*bbox_from_xywh(xywh))
 
+
 def xywh_from_bbox(minx, miny, maxx, maxy):
     """Convert a bounding box from a numeric list to a numeric dict representation."""
     return {
@@ -604,6 +631,7 @@ def xywh_from_bbox(minx, miny, maxx, maxy):
         'h': maxy - miny,
     }
 
+
 def xywh_from_points(points):
     """
     Construct a numeric dict representing a bounding box from polygon coordinates in page representation.

ocrd_utils/introspect.py

@@ -23,6 +23,7 @@ else:
 file_manager = ExitStack()
 atexit.register(file_manager.close)
 
+
 # Taken from https://github.com/OCR-D/core/pull/884
 def freeze_args(func):
     """
@@ -41,6 +42,7 @@ def membername(class_, val):
     """Convert a member variable/constant into a member name string."""
     return next((k for k, v in class_.__dict__.items() if v == val), str(val))
 
+
 def set_json_key_value_overrides(obj, *kvpairs):
     for kv in kvpairs:
         k, v = kv
@@ -50,13 +52,16 @@ def set_json_key_value_overrides(obj, *kvpairs):
             obj[k] = v
     return obj
 
-def resource_filename(pkg : str, fname : str) -> Path:
+
+def resource_filename(pkg: str, fname: str) -> Path:
     ref = importlib_resources.files(pkg) / fname
     return file_manager.enter_context(importlib_resources.as_file(ref))
 
-def resource_string(pkg : str, fname : str) -> str:
+
+def resource_string(pkg: str, fname: str) -> str:
     with open(resource_filename(pkg, fname), 'r', encoding='utf-8') as f:
         return f.read()
 
-def dist_version(module : str) -> str:
+
+def dist_version(module: str) -> str:
     return importlib_metadata.version(module)

ocrd_utils/logging.py

@@ -73,12 +73,13 @@ _ocrdLevel2pythonLevel = {
     'FATAL': 'ERROR',
 }
 
+
 def tf_disable_interactive_logs():
     try:
-        from os import environ # pylint: disable=import-outside-toplevel
+        from os import environ  # pylint: disable=import-outside-toplevel
         # This env variable must be set before importing from Keras
         environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
-        from tensorflow.keras.utils import disable_interactive_logging # pylint: disable=import-outside-toplevel
+        from tensorflow.keras.utils import disable_interactive_logging  # pylint: disable=import-outside-toplevel
         # Enabled interactive logging throws an exception
         # due to a call of sys.stdout.flush()
         disable_interactive_logging()
@@ -86,6 +87,7 @@ def tf_disable_interactive_logs():
         # Nothing should be handled here if TF is not available
         pass
 
+
 def getLevelName(lvl):
     """
     Get (string) python logging level for (string) spec-defined log level name.
@@ -93,6 +95,7 @@ def getLevelName(lvl):
     lvl = _ocrdLevel2pythonLevel.get(lvl, lvl)
     return logging.getLevelName(lvl)
 
+
 def getLogger(*args, **kwargs):
     """
     Wrapper around ``logging.getLogger`` that calls :py:func:`initLogging` if
@@ -101,6 +104,7 @@ def getLogger(*args, **kwargs):
     logger = logging.getLogger(*args, **kwargs)
     return logger
 
+
 def setOverrideLogLevel(lvl, silent=not config.OCRD_LOGGING_DEBUG):
     """
     Override the output log level of the handlers attached to the ``ocrd`` logger.
@@ -119,6 +123,7 @@ def setOverrideLogLevel(lvl, silent=not config.OCRD_LOGGING_DEBUG):
                 print(f'[LOGGING] Overriding {logger_name} log level to {lvl}', file=sys.stderr)
             logging.getLogger(logger_name).setLevel(lvl)
 
+
 def get_logging_config_files():
     """
     Return a list of all ``ocrd_logging.conf`` files found in CWD, HOME or /etc.
@@ -128,9 +133,9 @@ def get_logging_config_files():
         Path.home(),
         Path('/etc'),
     ]
-    return [f for f \
-            in [p / 'ocrd_logging.conf' for p in CONFIG_PATHS] \
-            if f.exists()]
+    return [file for file in [path / 'ocrd_logging.conf' for path in CONFIG_PATHS]
+            if file.exists()]
+
 
 def initLogging(builtin_only=False, force_reinit=False, silent=not config.OCRD_LOGGING_DEBUG):
     """
@@ -189,6 +194,7 @@ def initLogging(builtin_only=False, force_reinit=False, silent=not config.OCRD_L
             logging.getLogger(logger_name).setLevel(logger_level)
     _initialized_flag = True
 
+
 def disableLogging(silent=not config.OCRD_LOGGING_DEBUG):
     """
     Disables all logging of the ``ocrd`` logger and descendants
@@ -196,7 +202,7 @@ def disableLogging(silent=not config.OCRD_LOGGING_DEBUG):
     Keyword Args:
         - silent (bool, True): Whether to log logging behavior by printing to stderr
     """
-    global _initialized_flag # pylint: disable=global-statement
+    global _initialized_flag  # pylint: disable=global-statement
     if _initialized_flag and not silent:
         print("[LOGGING] Disabling logging", file=sys.stderr)
     _initialized_flag = False
@@ -212,4 +218,3 @@ def disableLogging(silent=not config.OCRD_LOGGING_DEBUG):
         logging.root.removeHandler(handler)
     # Python default log level is WARNING
     logging.root.setLevel(logging.WARNING)
-

ocrd_utils/os.py

@@ -36,6 +36,7 @@ from .config import config
 from .logging import getLogger
 from .introspect import resource_string
 
+
 def abspath(url):
     """
     Get a full path to a file or file URL
@@ -46,6 +47,7 @@ def abspath(url):
         url = url[len('file://'):]
     return abspath_(url)
 
+
 @contextmanager
 def pushd_popd(newcwd=None, tempdir=False):
     if newcwd and tempdir:
@@ -67,6 +69,7 @@ def pushd_popd(newcwd=None, tempdir=False):
     finally:
         chdir(oldcwd)
 
+
 def unzip_file_to_dir(path_to_zip, output_directory):
     """
     Extract a ZIP archive to a directory
@@ -74,13 +77,13 @@ def unzip_file_to_dir(path_to_zip, output_directory):
     with ZipFile(path_to_zip, 'r') as z:
         z.extractall(output_directory)
 
+
 @lru_cache()
 def get_ocrd_tool_json(executable):
     """
     Get the ``ocrd-tool`` description of ``executable``.
     """
     ocrd_tool = {}
-    executable_name = Path(executable).name
     try:
         ocrd_all_tool = loads(resource_string('ocrd', 'ocrd-all-tool.json'))
         ocrd_tool = ocrd_all_tool[executable]
@@ -93,6 +96,7 @@ def get_ocrd_tool_json(executable):
         ocrd_tool['resource_locations'] = ['data', 'cwd', 'system', 'module']
     return ocrd_tool
 
+
 @lru_cache()
 def get_moduledir(executable):
     moduledir = None
@@ -106,6 +110,7 @@ def get_moduledir(executable):
             getLogger('ocrd.utils.get_moduledir').error(f'{executable} --dump-module-dir failed: {e}')
     return moduledir
 
+
 def list_resource_candidates(executable, fname, cwd=getcwd(), moduled=None, xdg_data_home=None):
     """
     Generate candidates for processor resources according to
@@ -123,6 +128,7 @@ def list_resource_candidates(executable, fname, cwd=getcwd(), moduled=None, xdg_
         candidates.append(join(moduled, fname))
     return candidates
 
+
 def list_all_resources(executable, moduled=None, xdg_data_home=None):
     """
     List all processor resources in the filesystem according to
@@ -164,7 +170,7 @@ def list_all_resources(executable, moduled=None, xdg_data_home=None):
                    # code and data; `is_resource()` only singles out
                    # files over directories; but we want data files only
                    # todo: more code and cache exclusion patterns!
-                   ['*.py', '*.py[cod]', '*~', 'ocrd-tool.json', 
+                   ['*.py', '*.py[cod]', '*~', 'ocrd-tool.json',
                     'environment.pickle', 'resource_list.yml', 'lib.bash']):
                 continue
             candidates.append(resource)
@@ -174,6 +180,7 @@ def list_all_resources(executable, moduled=None, xdg_data_home=None):
             candidates += parent.iterdir()
     return sorted([str(x) for x in candidates])
 
+
 def get_processor_resource_types(executable, ocrd_tool=None):
     """
     Determine what type of resource parameters a processor needs.
@@ -194,6 +201,7 @@ def get_processor_resource_types(executable, ocrd_tool=None):
     return [p['content-type'] for p in ocrd_tool['parameters'].values()
             if 'content-type' in p]
 
+
 # ht @pabs3
 # https://github.com/untitaker/python-atomicwrites/issues/42
 class AtomicWriterPerms(AtomicWriter):
@@ -210,6 +218,7 @@ class AtomicWriterPerms(AtomicWriter):
         chmod(fd, mode)
         return f
 
+
 @contextmanager
 def atomic_write(fpath):
     with atomic_write_(fpath, writer_cls=AtomicWriterPerms, overwrite=True) as f:
@@ -224,6 +233,7 @@ def is_file_in_directory(directory, file):
     file = Path(file)
     return list(file.parts)[:len(directory.parts)] == list(directory.parts)
 
+
 def itertree(path):
     """
     Generate a list of paths by recursively enumerating ``path``
@@ -235,6 +245,7 @@ def itertree(path):
             yield from itertree(subpath)
     yield path
 
+
 def directory_size(path):
     """
     Calculates size of all files in directory ``path``
@@ -242,7 +253,8 @@ def directory_size(path):
     path = Path(path)
     return sum(f.stat().st_size for f in path.glob('**/*') if f.is_file())
 
-def guess_media_type(input_file : str, fallback : str = None, application_xml : str = 'application/xml'):
+
+def guess_media_type(input_file: str, fallback: str = None, application_xml: str = 'application/xml'):
     """
     Guess the media type of a file path
     """
@@ -259,6 +271,7 @@ def guess_media_type(input_file : str, fallback : str = None, application_xml :
         mimetype = application_xml
     return mimetype
 
+
 @contextmanager
 def redirect_stderr_and_stdout_to_file(filename):
     with open(filename, 'at', encoding='utf-8') as f: