ocrd_models.ocrd_mets.OcrdMets.find_files()

Complexity

Conditions

48

Size

Total Lines	126
Code Lines	76

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

"""
    def find_files(
        self,
        ID=None,
        fileGrp=None,
        pageId=None,
        mimetype=None,
        url=None,
        local_filename=None,
        local_only=False,
        include_fileGrp=None,
        exclude_fileGrp=None,
    ):
        """
        Search ``mets:file`` entries in this METS document and yield results.
        The :py:attr:`ID`, :py:attr:`pageId`, :py:attr:`fileGrp`,
        :py:attr:`url` and :py:attr:`mimetype` parameters can each be either a
        literal string, or a regular expression if the string starts with
        ``//`` (double slash).
        If it is a regex, the leading ``//`` is removed and candidates are matched
        against the regex with `re.fullmatch`. If it is a literal string, comparison
        is done with string equality.
        The :py:attr:`pageId` parameter supports the numeric range operator ``..``. For
        example, to find all files in pages ``PHYS_0001`` to ``PHYS_0003``,
        ``PHYS_0001..PHYS_0003`` will be expanded to ``PHYS_0001,PHYS_0002,PHYS_0003``.
        Keyword Args:
            ID (string) : ``@ID`` of the ``mets:file``
            fileGrp (string) : ``@USE`` of the ``mets:fileGrp`` to list files of
            pageId (string) : ``@ID`` of the corresponding physical ``mets:structMap`` entry (physical page)
            url (string) : ``@xlink:href`` remote/original URL of ``mets:Flocat`` of ``mets:file``
            local_filename (string) : ``@xlink:href`` local/cached filename of ``mets:Flocat`` of ``mets:file``
            mimetype (string) : ``@MIMETYPE`` of ``mets:file``
            local (boolean) : Whether to restrict results to local files in the filesystem
            include_fileGrp (list[str]) : Whitelist of allowd file groups 
            exclude_fileGrp (list[str]) : Blacklist of disallowd file groups 
        Yields:
            :py:class:`ocrd_models:ocrd_file:OcrdFile` instantiations
        """
        pageId_list = []
        if pageId:
            # returns divs instead of strings of ids
            physical_pages = self.get_physical_pages(for_pageIds=pageId, return_divs=True)
            for div in physical_pages:
                if self._cache_flag:
                    pageId_list += self._fptr_cache[div.get('ID')]
                else:
                    pageId_list += [fptr.get('FILEID') for fptr in div.findall('mets:fptr', NS)]

        if ID and ID.startswith(REGEX_PREFIX):
            ID = re.compile(ID[REGEX_PREFIX_LEN:])
        if fileGrp and fileGrp.startswith(REGEX_PREFIX):
            fileGrp = re.compile(fileGrp[REGEX_PREFIX_LEN:])
        if mimetype and mimetype.startswith(REGEX_PREFIX):
            mimetype = re.compile(mimetype[REGEX_PREFIX_LEN:])
        if url and url.startswith(REGEX_PREFIX):
            url = re.compile(url[REGEX_PREFIX_LEN:])

        candidates = []
        if self._cache_flag:
            if fileGrp:
                if isinstance(fileGrp, str):
                    candidates += self._file_cache.get(fileGrp, {}).values()
                else:
                    candidates = [x for fileGrp_needle, el_file_list in self._file_cache.items() if
                                  fileGrp.match(fileGrp_needle) for x in el_file_list.values()]
            else:
                candidates = [el_file for id_to_file in self._file_cache.values() for el_file in id_to_file.values()]
        else:
            candidates = self._tree.getroot().xpath('//mets:file', namespaces=NS)

        for cand in candidates:
            if ID:
                if isinstance(ID, str):
                    if not ID == cand.get('ID'): continue
                else:
                    if not ID.fullmatch(cand.get('ID')): continue

            if pageId is not None and cand.get('ID') not in pageId_list:
                continue

            if not self._cache_flag and fileGrp:
                if isinstance(fileGrp, str):
                    if cand.getparent().get('USE') != fileGrp: continue
                else:
                    if not fileGrp.fullmatch(cand.getparent().get('USE')): continue

            if mimetype:
                if isinstance(mimetype, str):
                    if cand.get('MIMETYPE') != mimetype: continue
                else:
                    if not mimetype.fullmatch(cand.get('MIMETYPE') or ''): continue

            if url:
                cand_locat = cand.find('mets:FLocat[@LOCTYPE="URL"]', namespaces=NS)
                if cand_locat is None:
                    continue
                cand_url = cand_locat.get('{%s}href' % NS['xlink'])
                if isinstance(url, str):
                    if cand_url != url: continue
                else:
                    if not url.fullmatch(cand_url): continue

            if local_filename:
                cand_locat = cand.find('mets:FLocat[@LOCTYPE="OTHER"][@OTHERLOCTYPE="FILE"]', namespaces=NS)
                if cand_locat is None:
                    continue
                cand_local_filename = cand_locat.get('{%s}href' % NS['xlink'])
                if isinstance(local_filename, str):
                    if cand_local_filename != local_filename: continue
                else:
                    if not local_filename.fullmatch(cand_local_filename): continue

            if local_only:
                # deprecation_warning("'local_only' is deprecated, use 'local_filename=\"//.+\"' instead")
                is_local = cand.find('mets:FLocat[@LOCTYPE="OTHER"][@OTHERLOCTYPE="FILE"][@xlink:href]', namespaces=NS)
                if is_local is None:
                    continue

            ret = OcrdFile(cand, mets=self)

            # XXX include_fileGrp is redundant to fileGrp but for completeness
            if exclude_fileGrp and ret.fileGrp in exclude_fileGrp:
                continue
            if include_fileGrp and ret.fileGrp not in include_fileGrp:
                continue

            yield ret