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

ocrd_validators/json_validator.py

@@ -2,7 +2,6 @@
 Validating JSON-Schema
 """
 import json
-from warnings import warn
 
 from jsonschema import Draft201909Validator, ValidationError, validators # pylint: disable=import-error
 
@@ -28,8 +27,7 @@ def extend_with_default(validator_class):
             if subschema.get('deprecated', False) and instance.get(prop):
                 yield JsonSchemaDeprecationWarning(f"Property {prop} has been deprecated, ocrd-tool.json should be updated.")
 
-        for error in validate_properties(validator, properties, instance, schema):
-            yield error
+        yield from validate_properties(validator, properties, instance, schema)
 
     return validators.extend(validator_class, {"properties": set_defaults_and_handle_deprecate})
 

ocrd_validators/ocrd_tool_validator.py

@@ -22,5 +22,5 @@ class OcrdToolValidator(JsonValidator):
         """
         return OcrdToolValidator(schema)._validate(obj) # pylint: disable=protected-access
 
-    def __init__(self, schema, validator_class=...):
-        super().__init__(schema, DefaultValidatingDraft20199Validator)
+    def __init__(self, schema):
+        super().__init__(schema, validator_class=DefaultValidatingDraft20199Validator)

ocrd_validators/page_validator.py

@@ -34,50 +34,50 @@ from ocrd_models import ValidationReport
 
 _HIERARCHY = [
     # page can contain different types of regions
-    (PageType,       'get_AdvertRegion', None), # pylint: disable=bad-whitespace
-    (PageType,       'get_ChartRegion', None), # pylint: disable=bad-whitespace
-    (PageType,       'get_ChemRegion', None), # pylint: disable=bad-whitespace
-    (PageType,       'get_CustomRegion', None), # pylint: disable=bad-whitespace
-    (PageType,       'get_GraphicRegion', None), # pylint: disable=bad-whitespace
-    (PageType,       'get_ImageRegion', None), # pylint: disable=bad-whitespace
-    (PageType,       'get_LineDrawingRegion', None), # pylint: disable=bad-whitespace
-    (PageType,       'get_MapRegion', None), # pylint: disable=bad-whitespace
-    (PageType,       'get_MathsRegion', None), # pylint: disable=bad-whitespace
-    (PageType,       'get_MusicRegion', None), # pylint: disable=bad-whitespace
-    (PageType,       'get_NoiseRegion', None), # pylint: disable=bad-whitespace
-    (PageType,       'get_SeparatorRegion', None), # pylint: disable=bad-whitespace
-    (PageType,       'get_TableRegion', None), # pylint: disable=bad-whitespace
-    (PageType,       'get_TextRegion', None), # pylint: disable=bad-whitespace
-    (PageType,       'get_UnknownRegion', None), # pylint: disable=bad-whitespace
+    (PageType,       'get_AdvertRegion', None),
+    (PageType,       'get_ChartRegion', None),
+    (PageType,       'get_ChemRegion', None),
+    (PageType,       'get_CustomRegion', None),
+    (PageType,       'get_GraphicRegion', None),
+    (PageType,       'get_ImageRegion', None),
+    (PageType,       'get_LineDrawingRegion', None),
+    (PageType,       'get_MapRegion', None),
+    (PageType,       'get_MathsRegion', None),
+    (PageType,       'get_MusicRegion', None),
+    (PageType,       'get_NoiseRegion', None),
+    (PageType,       'get_SeparatorRegion', None),
+    (PageType,       'get_TableRegion', None),
+    (PageType,       'get_TextRegion', None),
+    (PageType,       'get_UnknownRegion', None),
     # all regions can be recursive
-    (RegionType,     'get_AdvertRegion', None), # pylint: disable=bad-whitespace
-    (RegionType,     'get_ChartRegion', None), # pylint: disable=bad-whitespace
-    (RegionType,     'get_ChemRegion', None), # pylint: disable=bad-whitespace
-    (RegionType,     'get_CustomRegion', None), # pylint: disable=bad-whitespace
-    (RegionType,     'get_GraphicRegion', None), # pylint: disable=bad-whitespace
-    (RegionType,     'get_ImageRegion', None), # pylint: disable=bad-whitespace
-    (RegionType,     'get_LineDrawingRegion', None), # pylint: disable=bad-whitespace
-    #(RegionType,     'get_MapRegion', None), # pylint: disable=bad-whitespace
-    (RegionType,     'get_MathsRegion', None), # pylint: disable=bad-whitespace
-    (RegionType,     'get_MusicRegion', None), # pylint: disable=bad-whitespace
-    (RegionType,     'get_NoiseRegion', None), # pylint: disable=bad-whitespace
-    (RegionType,     'get_SeparatorRegion', None), # pylint: disable=bad-whitespace
-    (RegionType,     'get_TableRegion', None), # pylint: disable=bad-whitespace
-    (RegionType,     'get_TextRegion', None), # pylint: disable=bad-whitespace
-    (RegionType,     'get_UnknownRegion', None), # pylint: disable=bad-whitespace
+    (RegionType,     'get_AdvertRegion', None),
+    (RegionType,     'get_ChartRegion', None),
+    (RegionType,     'get_ChemRegion', None),
+    (RegionType,     'get_CustomRegion', None),
+    (RegionType,     'get_GraphicRegion', None),
+    (RegionType,     'get_ImageRegion', None),
+    (RegionType,     'get_LineDrawingRegion', None),
+    #(RegionType,     'get_MapRegion', None),
+    (RegionType,     'get_MathsRegion', None),
+    (RegionType,     'get_MusicRegion', None),
+    (RegionType,     'get_NoiseRegion', None),
+    (RegionType,     'get_SeparatorRegion', None),
+    (RegionType,     'get_TableRegion', None),
+    (RegionType,     'get_TextRegion', None),
+    (RegionType,     'get_UnknownRegion', None),
     # only TextRegion can contain TextLine
-    (TextRegionType, 'get_TextLine',   '\n'), # pylint: disable=bad-whitespace
-    (TextLineType,   'get_Word',       ' '),  # pylint: disable=bad-whitespace
-    (WordType,       'get_Glyph',      ''),   # pylint: disable=bad-whitespace
-    (GlyphType,      None,             None), # pylint: disable=bad-whitespace
+    (TextRegionType, 'get_TextLine',   '\n'),
+    (TextLineType,   'get_Word',       ' '),
+    (WordType,       'get_Glyph',      ''),
+    (GlyphType,      None,             None),
 ]
 
 _ORDER = [
     (None, TextLineOrderSimpleType.BOTTOMTOTOP, ReadingDirectionSimpleType.RIGHTTOLEFT),
-    (PageType,       'get_textLineOrder', 'get_readingDirection'), # pylint: disable=bad-whitespace
-    (TextRegionType, 'get_textLineOrder', 'get_readingDirection'), # pylint: disable=bad-whitespace
-    (TextLineType,   None,                'get_readingDirection'), # pylint: disable=bad-whitespace
-    (WordType,       None,                'get_readingDirection'), # pylint: disable=bad-whitespace
+    (PageType,       'get_textLineOrder', 'get_readingDirection'),
+    (TextRegionType, 'get_textLineOrder', 'get_readingDirection'),
+    (TextLineType,   None,                'get_readingDirection'),
+    (WordType,       None,                'get_readingDirection'),
 ]
 
 # The following parameters control how tolerant we are with respect to
@@ -115,9 +115,9 @@ class ConsistencyError(Exception):
         self.file_id = file_id
         self.actual = actual
         self.expected = expected
-        super(ConsistencyError, self).__init__(
-            "INCONSISTENCY in %s ID '%s' of file '%s': text results '%s' != concatenated '%s'" % (
-                tag, ID, file_id, actual, expected))
+        super().__init__(
+            f"INCONSISTENCY in {tag} ID '{ID}' of file '{file_id}': "
+            f"text results '{actual}' != concatenated '{expected}'")
 
 class CoordinateConsistencyError(Exception):
     """
@@ -141,9 +141,9 @@ class CoordinateConsistencyError(Exception):
         self.file_id = file_id
         self.outer = outer
         self.inner = inner
-        super(CoordinateConsistencyError, self).__init__(
-            "INCONSISTENCY in %s ID '%s' of '%s': coords '%s' not within parent coords '%s'" % (
-                tag, ID, file_id, inner, outer))
+        super().__init__(
+            f"INCONSISTENCY in {tag} ID '{ID}' of '{file_id}': "
+            f"coords '{inner}' not within parent coords '{outer}'")
 
 class CoordinateValidityError(Exception):
     """
@@ -166,9 +166,8 @@ class CoordinateValidityError(Exception):
         self.ID = ID
         self.file_id = file_id
         self.points = points
-        super(CoordinateValidityError, self).__init__(
-            "INVALIDITY in %s ID '%s' of '%s': coords '%s' - %s" % (
-                tag, ID, file_id, points, reason))
+        super().__init__(
+            f"INVALIDITY in {tag} ID '{ID}' of '{file_id}': coords '{points}' - {reason}")
 
 def compare_without_whitespace(a, b):
     """
@@ -177,13 +176,14 @@ def compare_without_whitespace(a, b):
     return re.sub('\\s+', '', a) == re.sub('\\s+', '', b)
 
 def page_get_reading_order(ro, rogroup):
-    """Add all elements from the given reading order group to the given dictionary.
-    
+    """
+    Add all elements from the given reading order group to the given dictionary.
+
     Given a dict ``ro`` from layout element IDs to ReadingOrder element objects,
     and an object ``rogroup`` with additional ReadingOrder element objects,
     add all references to the dict, traversing the group recursively.
     """
-    regionrefs = list()
+    regionrefs = []
     if isinstance(rogroup, (OrderedGroupType, OrderedGroupIndexedType)):
         regionrefs = (rogroup.get_RegionRefIndexed() +
                       rogroup.get_OrderedGroupIndexed() +
@@ -241,12 +241,12 @@ def validate_consistency(node, page_textequiv_consistency, page_textequiv_strate
         node_id = node.get_pcGtsId()
         node = node.get_Page() # has no .id
         if not readingOrder:
-            readingOrder = dict()
+            readingOrder = {}
         ro = node.get_ReadingOrder()
         if ro:
             page_get_reading_order(readingOrder, ro.get_OrderedGroup() or ro.get_UnorderedGroup())
         if not joinRelations:
-            joinRelations = list()
+            joinRelations = []
         relations = node.get_Relations() # get RelationsType
         if relations:
             relations = relations.get_Relation() # get list of RelationType
@@ -358,7 +358,7 @@ def concatenate(nodes, concatenate_with, page_textequiv_strategy, joins=None):
     if not nodes:
         return ''
     if not joins:
-        joins = list()
+        joins = []
     result = get_text(nodes[0], page_textequiv_strategy)
     for node, next_node in zip(nodes, nodes[1:]):
         if (node.id, next_node.id) not in joins:
@@ -470,11 +470,11 @@ class PageValidator():
             page = parse(filename, silence=True)
             file_id = filename
         else:
-            raise Exception("At least one of ocrd_page, ocrd_file or filename must be set")
+            raise ValueError("At least one of ocrd_page, ocrd_file or filename must be set")
         if page_textequiv_strategy not in ('first'):
-            raise Exception("page_textequiv_strategy %s not implemented" % page_textequiv_strategy)
+            raise ValueError("page_textequiv_strategy %s not implemented" % page_textequiv_strategy)
         if page_textequiv_consistency not in ('strict', 'lax', 'fix', 'off'):
-            raise Exception("page_textequiv_consistency level %s not implemented" % page_textequiv_consistency)
+            raise ValueError("page_textequiv_consistency level %s not implemented" % page_textequiv_consistency)
         report = ValidationReport()
         log.info("Validating input file '%s'", file_id)
         validate_consistency(page, page_textequiv_consistency, page_textequiv_strategy, check_baseline, check_coords, report, file_id)

ocrd_validators/parameter_validator.py

@@ -20,7 +20,7 @@ class ParameterValidator(JsonValidator):
             obj (dict):
             schema (dict):
         """
-        return super(ParameterValidator, self)._validate(*args, **kwargs)
+        return super()._validate(*args, **kwargs)
 
     def __init__(self, ocrd_tool):
         """
@@ -40,7 +40,7 @@ class ParameterValidator(JsonValidator):
                 if p[n]['required']:
                     required.append(n)
                 del(p[n]['required'])
-        super(ParameterValidator, self).__init__({
+        super().__init__({
             "type": "object",
             "required": required,
             "additionalProperties": False,

ocrd_validators/resource_list_validator.py

@@ -16,9 +16,10 @@ class OcrdResourceListValidator(JsonValidator):
     """
 
     @staticmethod
-    def validate(obj, schema=RESOURCE_LIST_SCHEMA):
+    def validate(obj, schema=None):
         """
         Validate against ``resource_list.schema.yml`` schema.
         """
-        return JsonValidator(schema, validator_class=DefaultValidatingDraft20199Validator)._validate(obj)
-
+        if schema is None:
+            schema = RESOURCE_LIST_SCHEMA
+        return JsonValidator(schema, validator_class=DefaultValidatingDraft20199Validator)._validate(obj) # pylint: disable=protected-access

ocrd_validators/workspace_validator.py

@@ -103,7 +103,7 @@ class WorkspaceValidator():
                                                 'page_xsd']
                             if check not in self.skip]
 
-        self.find_kwargs = dict(include_fileGrp=include_fileGrp, exclude_fileGrp=exclude_fileGrp)
+        self.find_kwargs = {"include_fileGrp": include_fileGrp, "exclude_fileGrp": exclude_fileGrp}
         self.src_dir = src_dir
         self.workspace = None
         self.mets = None
@@ -139,7 +139,7 @@ class WorkspaceValidator():
             self._resolve_workspace()
         except Exception as e: # pylint: disable=broad-except
             self.log.warning("Failed to instantiate workspace: %s", e)
-            self.report.add_error("Failed to instantiate workspace: %s" % e)
+            self.report.add_error(f"Failed to instantiate workspace: {e}")
             return self.report
         with pushd_popd(self.workspace.directory):
             try:
@@ -158,7 +158,7 @@ class WorkspaceValidator():
                 if self.page_checks:
                     self._validate_page()
             except Exception: # pylint: disable=broad-except
-                self.report.add_error("Validation aborted with exception: %s" % format_exc())
+                self.report.add_error(f"Validation aborted with exception: {format_exc()}")
         return self.report
 
     def _resolve_workspace(self):
@@ -193,9 +193,9 @@ class WorkspaceValidator():
             page = page_from_file(f).get_Page()
             imageFilename = page.imageFilename
             if not self.mets.find_files(url=imageFilename, **self.find_kwargs):
-                self.report.add_error("PAGE-XML %s : imageFilename '%s' not found in METS" % (f.local_filename, imageFilename))
+                self.report.add_error(f"PAGE '{f.ID}': imageFilename '{imageFilename}' not found in METS")
             if is_local_filename(imageFilename) and not Path(imageFilename).exists():
-                self.report.add_warning("PAGE-XML %s : imageFilename '%s' points to non-existent local file" % (f.local_filename, imageFilename))
+                self.report.add_warning(f"PAGE '{f.ID}': imageFilename '{imageFilename}' points to non-existent local file")
 
     def _validate_dimension(self):
         """
@@ -210,9 +210,9 @@ class WorkspaceValidator():
             page = page_from_file(f).get_Page()
             _, _, exif = self.workspace.image_from_page(page, f.pageId)
             if page.imageHeight != exif.height:
-                self.report.add_error("PAGE '%s': @imageHeight != image's actual height (%s != %s)" % (f.ID, page.imageHeight, exif.height))
+                self.report.add_error(f"PAGE '{f.ID}': @imageHeight != image's actual height ({page.imageHeight} != {exif.height})")
             if page.imageWidth != exif.width:
-                self.report.add_error("PAGE '%s': @imageWidth != image's actual width (%s != %s)" % (f.ID, page.imageWidth, exif.width))
+                self.report.add_error(f"PAGE '{f.ID}': @imageWidth != image's actual width ({page.imageWidth} != {exif.width})")
 
     def _validate_multipage(self):
         """
@@ -229,9 +229,9 @@ class WorkspaceValidator():
             try:
                 exif = self.workspace.resolve_image_exif(f.local_filename)
                 if exif.n_frames > 1:
-                    self.report.add_error("Image %s: More than 1 frame: %s" % (f.ID, exif.n_frames))
+                    self.report.add_error(f"Image '{f.ID}': More than 1 frame: {exif.n_frames}")
             except FileNotFoundError:
-                self.report.add_error("Image %s: Could not retrieve %s (local_filename=%s, url=%s)" % (f.ID, f.local_filename, f.url))
+                self.report.add_error(f"Image '{f.ID}': Could not retrieve (local_filename='{f.local_filename}', url='{f.url}')")
                 return
 
     def _validate_pixel_density(self):
@@ -250,7 +250,7 @@ class WorkspaceValidator():
             for k in ['xResolution', 'yResolution']:
                 v = exif.__dict__.get(k)
                 if v is None or v <= 72:
-                    self.report.add_notice("Image %s: %s (%s pixels per %s) is suspiciously low" % (f.ID, k, v, exif.resolutionUnit))
+                    self.report.add_notice(f"Image '{f.ID}': {k} ({v} pixels per {exif.resolutionUnit}) is suspiciously low")
 
     def _validate_mets_file_group_names(self):
         """
@@ -261,7 +261,7 @@ class WorkspaceValidator():
         self.log.debug('_validate_mets_file_group_names')
         for fileGrp in self.mets.file_groups:
             if not fileGrp.startswith(FILE_GROUP_PREFIX):
-                self.report.add_notice("fileGrp USE does not begin with '%s': %s" % (FILE_GROUP_PREFIX, fileGrp))
+                self.report.add_notice(f"fileGrp USE '{fileGrp}' does not begin with '{FILE_GROUP_PREFIX}'")
             else:
                 # OCR-D-FOO-BAR -> ('FOO', 'BAR')
                 # \____/\_/ \_/
@@ -273,9 +273,9 @@ class WorkspaceValidator():
                 if '-' in category:
                     category, name = category.split('-', 1)
                 if category not in FILE_GROUP_CATEGORIES:
-                    self.report.add_notice("Unspecified USE category '%s' in fileGrp '%s'" % (category, fileGrp))
+                    self.report.add_notice(f"Unspecified USE category '{category}' in fileGrp '{fileGrp}'")
                 if name is not None and not re.match(r'^[A-Z0-9-]{3,}$', name):
-                    self.report.add_notice("Invalid USE name '%s' in fileGrp '%s'" % (name, fileGrp))
+                    self.report.add_notice(f"Invalid USE name '{name}' in fileGrp '{fileGrp}'")
 
     def _validate_mets_files(self):
         """
@@ -288,16 +288,16 @@ class WorkspaceValidator():
             self.report.add_error("No files")
         for f in self.mets.find_files(**self.find_kwargs):
             if f._el.get('GROUPID'): # pylint: disable=protected-access
-                self.report.add_notice("File '%s' has GROUPID attribute - document might need an update" % f.ID)
+                self.report.add_notice(f"File '{f.ID}' has GROUPID attribute - document might need an update")
             if not (f.url or f.local_filename):
-                self.report.add_error("File '%s' has neither mets:Flocat[@LOCTYPE='URL']/@xlink:href nor mets:FLocat[@LOCTYPE='OTHER'][@OTHERLOCTYPE='FILE']/xlink:href" % f.ID)
+                self.report.add_error(f"File '{f.ID}' has neither mets:Flocat[@LOCTYPE='URL']/@xlink:href nor mets:FLocat[@LOCTYPE='OTHER'][@OTHERLOCTYPE='FILE']/xlink:href")
                 continue
             if f.url and 'url' not in self.skip:
                 if re.match(r'^file:/[^/]', f.url):
-                    self.report.add_error("File '%s' has an invalid (Java-specific) file URL '%s'" % (f.ID, f.url))
+                    self.report.add_error(f"File '{f.ID}' has an invalid (Java-specific) file URL '{f.url}'")
                 scheme = f.url[0:f.url.index(':')]
                 if scheme not in ('http', 'https', 'file'):
-                    self.report.add_warning("File '%s' has non-HTTP, non-file URL '%s'" % (f.ID, f.url))
+                    self.report.add_warning(f"File '{f.ID}' has non-HTTP, non-file URL '{f.url}'")
 
     def _validate_page(self):
         """
@@ -323,15 +323,15 @@ class WorkspaceValidator():
             if 'dimension' in self.page_checks:
                 _, _, exif = self.workspace.image_from_page(page, f.pageId)
                 if page.imageHeight != exif.height:
-                    self.report.add_error("PAGE '%s': @imageHeight != image's actual height (%s != %s)" % (f.ID, page.imageHeight, exif.height))
+                    self.report.add_error(f"PAGE '{f.ID}': @imageHeight != image's actual height ({page.imageHeight} != {exif.height})")
                 if page.imageWidth != exif.width:
-                    self.report.add_error("PAGE '%s': @imageWidth != image's actual width (%s != %s)" % (f.ID, page.imageWidth, exif.width))
+                    self.report.add_error(f"PAGE '{f.ID}': @imageWidth != image's actual width ({page.imageWidth} != {exif.width})")
             if 'imagefilename' in self.page_checks:
                 imageFilename = page.imageFilename
                 if not self.mets.find_files(url=imageFilename):
-                    self.report.add_error("PAGE-XML %s : imageFilename '%s' not found in METS" % (f.url, imageFilename))
+                    self.report.add_error(f"PAGE '{f.ID}': imageFilename '{imageFilename}' not found in METS")
                 if is_local_filename(imageFilename) and not Path(imageFilename).exists():
-                    self.report.add_warning("PAGE-XML %s : imageFilename '%s' points to non-existent local file" % (f.url, imageFilename))
+                    self.report.add_warning(f"PAGE '{f.ID}': imageFilename '{imageFilename}' points to non-existent local file")
             if 'mets_fileid_page_pcgtsid' in self.page_checks and pcgts.pcGtsId != f.ID:
                 self.report.add_warning('pc:PcGts/@pcGtsId differs from mets:file/@ID: "%s" !== "%s"' % (pcgts.pcGtsId or '', f.ID or ''))
 

ocrd_validators/xsd_validator.py

@@ -45,7 +45,7 @@ class XsdValidator():
             schema_url (str): URI of XML schema to validate against.
         """
         if schema_url not in XSD_PATHS:
-            raise Exception('XML schema not bundled with OCR-D: %s' % schema_url)
+            raise ValueError('XML schema not bundled with OCR-D: %s' % schema_url)
         with open(XSD_PATHS[schema_url], 'r') as f:
             xmlschema_doc = ET.parse(f)
             self._xmlschema = ET.XMLSchema(xmlschema_doc)