protoerror 3.20.2__py3-none-any.whl

protoerror/control.py

@@ -0,0 +1,330 @@
+# =============================================================================
+# C O P Y R I G H T
+# -----------------------------------------------------------------------------
+# Copyright (c) 2020-2022 by Helmut Konrad Fahrendholz. All rights reserved.
+# This file is property of Helmut Konrad Fahrendholz. Any unauthorized copy,
+# use or distribution is an offensive act against international law and may
+# be prosecuted under federal law. Its content is company confidential.
+# =============================================================================
+"""Control the checker
+===================
+
+Use decorators to exclude linter step cause the step has a problem or
+implementation is not finished yet:
+
+.. code-block:: python
+
+    @skip
+    def check_1282_skip_step():
+        pass
+
+Skip linter step for special document length:
+
+.. code-block:: python
+
+    @nosmall
+    @nomedium
+    def check_1290_long_page_check():
+        pass
+
+Supported Decorators: @nosmall, @nomedium, @nolarge
+
+Run linter for a special document type:
+
+.. code-block:: python
+
+    @book
+    def check_1291_page_border():
+        pass
+
+Supported Decorators: @homework, @bachelor, @master, @dissertation, @diss, @book
+
+Examples
+--------
+
+>>> @homework
+... @nolarge
+... def check_1234(items):
+...    pass
+
+Get list of decorators for a linter step:
+
+>>> decorators(check_1234)
+['nolarge', 'homework']
+
+>>> @homework
+... @disable_perpage(morethan=20)
+... def check_touch_too_much():
+...     pass
+
+>>> decorators(check_touch_too_much)
+[{'disable_perpage': {'morethan': 20}}, 'homework']
+
+Templates: Doctype based replacement
+====================================
+
+Add selective advice which are platform dependent, for example give
+different advice when using MSWord instead of Latex:
+
+.. code-block:: python
+
+    {% if MSWORD %}
+    ...
+    {% endif %}
+
+    {% if LATEX %}
+    ...
+    {% endif %}
+
+    {% if BASE %}
+    ...
+    {% endif %}
+"""
+
+import contextlib
+
+import configos
+import iamraw
+import utilo
+
+MAX_SMALL_PAGE_LENGTH = configos.HV_INT_PLUS(default=35)
+MAX_MEDIUM_PAGE_LENGTH = configos.HV_INT_PLUS(default=35)
+
+DOCTYPES = [item.name.lower() for item in iamraw.DocumentType]
+
+
+def filter_checkers(items: list, document: iamraw.DocInfo) -> list:
+    current = document.doctype.name.lower() if document.doctype else None
+    result = []
+    for item in items:
+        decorated = decorators(item)
+        if should_skip(decorated, document):
+            continue
+        if current:
+            # skipped document type
+            if f'no{current}' in decorated:
+                # nohome nobachelor etc.
+                continue
+            # is check decorated for a special doctype
+            some = any(item in decorated for item in DOCTYPES)
+            if some and current not in decorated:
+                # current document is not selected by decorators, but
+                # others are. Therefore we have to skip this ckeck,
+                # because this check was not made for current document
+                # type.
+                continue
+        result.append(item)
+    return result
+
+
+def should_skip(decorated, document) -> bool:
+    if document.pages is not None:
+        small = document.pages < MAX_SMALL_PAGE_LENGTH
+        medium = MAX_SMALL_PAGE_LENGTH <= document.pages < MAX_MEDIUM_PAGE_LENGTH
+        large = MAX_MEDIUM_PAGE_LENGTH <= document.pages < utilo.INF
+    else:
+        small, medium, large = False, False, False
+    # deactivated method
+    if 'skip' in decorated:
+        return True
+    # verify document length
+    if small and 'nosmall' in decorated:
+        return True
+    if medium and 'nomedium' in decorated:
+        return True
+    if large and 'nolarge' in decorated:
+        return True
+    if 'german' in decorated and 'english' not in decorated:
+        if document.lang and document.lang != iamraw.Language.GERMAN:
+            return True
+    return False
+
+
+def decorateme(method, value):
+    try:
+        assert value not in method.__control__, str(method.__control__)
+        method.__control__.append(value)
+    except AttributeError:
+        setattr(method, '__control__', [value])
+    return method
+
+
+def decorators(method) -> set:
+    assert method, str(method)
+    with contextlib.suppress(AttributeError):
+        return method.__control__
+    return []
+
+
+# pylint:disable=C0103
+homework = lambda x: decorateme(x, 'homework')
+bachelor = lambda x: decorateme(x, 'bachelor')
+master = lambda x: decorateme(x, 'master')
+diss = lambda x: decorateme(x, 'diss')
+dissertation = diss
+book = lambda x: decorateme(x, 'book')
+paper = lambda x: decorateme(x, 'paper')
+# exluce length of document
+nosmall = lambda x: decorateme(x, 'nosmall')
+nomedium = lambda x: decorateme(x, 'nomedium')
+nolarge = lambda x: decorateme(x, 'nolarge')
+# exclude types of document
+nohome = lambda x: decorateme(x, 'nohomework')
+nobachelor = lambda x: decorateme(x, 'nobachelor')
+nomaster = lambda x: decorateme(x, 'nomaster')
+nodiss = lambda x: decorateme(x, 'nodiss')
+nobook = lambda x: decorateme(x, 'nobook')
+nopaper = lambda x: decorateme(x, 'nopaper')
+
+german = lambda x: decorateme(x, 'german')
+english = lambda x: decorateme(x, 'english')
+
+skip = lambda x: decorateme(x, 'skip')
+
+
+def section_skip(sections: iamraw.PartOfDocMixin = None):
+    return lambda x: decorateme(x, {'section_skip': sections})
+
+
+def section_only(sections: iamraw.PartOfDocMixin = None):
+    return lambda x: decorateme(x, {'section_only': sections})
+
+
+def only_skip(method):
+    only, skips = set(), set()
+    try:
+        control = method.__control__
+    except AttributeError:
+        return only, skips
+    for item in control:
+        if 'section_only' in item:
+            only.add(item['section_only'])
+        if 'section_skip' in item:
+            skips.add(item['section_skip'])
+    return only, skips
+
+
+def disable_perpage(lessthan=None, morethan=None, equal=None):
+    values = {}
+    if lessthan is not None:
+        values['lessthan'] = lessthan
+    if morethan is not None:
+        values['morethan'] = morethan
+    if equal is not None:
+        values['equal'] = equal
+    return lambda x: decorateme(x, {'disable_perpage': values})
+
+
+def enable_perpage(lessthan=None, morethan=None, equal=None):
+    values = {}
+    if lessthan is not None:
+        values['lessthan'] = lessthan
+    if morethan is not None:
+        values['morethan'] = morethan
+    if equal is not None:
+        values['equal'] = equal
+    return lambda x: decorateme(x, {'enable_perpage': values})
+
+
+def get_perpage(methods):
+    result = []
+    for method in methods:
+        decorator = decorators(method)
+        if 'perpage' not in str(decorator):
+            continue
+        result.append(method)
+    return result
+
+
+def is_disabled_perpage(findings, method) -> bool:
+    control = method.__control__
+    for item in control:
+        try:
+            disableperpage = item['disable_perpage']
+        except (TypeError, KeyError):
+            continue
+        with contextlib.suppress(KeyError):
+            if disableperpage['equal'] == len(findings):
+                return True
+        with contextlib.suppress(KeyError):
+            if len(findings) <= disableperpage['lessthan']:
+                return True
+        with contextlib.suppress(KeyError):
+            if len(findings) >= disableperpage['morethan']:
+                return True
+    return False
+
+
+DOCINFO_PATTERN = utilo.compiles(r"""
+    ^
+    (?P<typ>homework|bachelor|master|diss|habil|book|paper)?
+    (?P<pages>\d{1,4})?
+    (?P<lang>ger|eng|fre|german|english|french)?
+    $
+""")
+
+DOCINFO = 'bachelor64ger'
+
+
+def parse_docinfo(docinfo) -> iamraw.DocInfo:
+    """\
+    >>> parse_docinfo('diss215eng')
+    DocInfo(pages=215, doctype=...DISS...lang=...ENGLISH...)
+    >>> parse_docinfo('15GER')
+    DocInfo(pages=15...NONE...lang=<Language.GERMAN...)
+    >>> assert parse_docinfo(None) is None
+    """
+    if not docinfo:
+        return None
+    parsed = DOCINFO_PATTERN.match(docinfo)
+    if not parsed:
+        return None
+    doctype = iamraw.DocumentType.NONE
+    pages = 256
+    lang = iamraw.Language.GERMAN  # default lang
+    with contextlib.suppress(KeyError):
+        if parsed['pages']:
+            pages = int(parsed['pages'])
+    with contextlib.suppress(KeyError, AttributeError):
+        doctype = iamraw.DocumentType[parsed['typ'].upper()]
+    with contextlib.suppress(KeyError):
+        if parsed['lang']:
+            lang = parse_lang(parsed['lang'])
+    result = iamraw.DocInfo(
+        pages=pages,
+        doctype=doctype,
+        lang=lang,
+    )
+    return result
+
+
+def parse_lang(lang: str) -> iamraw.Language:
+    lang = lang.lower()
+    if lang in 'german':
+        return iamraw.Language.GERMAN
+    if lang in 'english':
+        return iamraw.Language.ENGLISH
+    if lang in 'french':
+        return iamraw.Language.FRENCH
+    return iamraw.Language.UNKNOWN
+
+
+def integrate_docinfo():
+    hook = integrate_cli
+    run = evaluate_userchoice
+    return hook, run
+
+
+def evaluate_userchoice(argv):
+    docinfo = argv.get('docinfo', None)
+    parsed = parse_docinfo(docinfo)
+    if parsed is None:
+        parsed = iamraw.DocInfo()
+    return {'docinfo': parsed}
+
+
+def integrate_cli(parser):
+    parser.add_argument(
+        '--docinfo',
+        help='define docinfo to tell document type, length and language',
+    )

protoerror/finding.py

@@ -0,0 +1,145 @@
+# =============================================================================
+# C O P Y R I G H T
+# -----------------------------------------------------------------------------
+# Copyright (c) 2019-2022 by Helmut Konrad Fahrendholz. All rights reserved.
+# This file is property of Helmut Konrad Fahrendholz. Any unauthorized copy,
+# use or distribution is an offensive act against international law and may
+# be prosecuted under federal law. Its content is company confidential.
+# =============================================================================
+
+import concurrent.futures
+import os
+
+import iamraw
+import serializeraw
+import utilo
+
+import protoerror
+
+
+def findings_from_path(
+    path: str,
+    worker: int = 10,
+    useronly: bool = True,
+    msgid: set = None,
+) -> iamraw.PageFindings:
+    """Load Findings from `path` directory and group them by page as
+    `PageFindings`."""
+    assert os.path.isdir(path), str(path)
+    files = utilo.file_list(path, include='yaml', recursive=True)
+    if useronly:
+        files = [
+            item for item in files if utilo.file_name(item).endswith('_user')
+        ]
+    paths = [os.path.join(path, item) for item in files]
+    # limit worker by max file count
+    worker = utilo.mins(worker, len(files))
+    # ensure to have at least one worker when collection now file
+    worker = utilo.maxs(1, worker)
+    # yaml parsing is cpu bound, therefore we need a process pool instead
+    # of thread pool.
+    executor = utilo.select_executor()
+    with executor(max_workers=worker) as executor:
+        todo = {
+            executor.submit(serializeraw.load_findings, path): path
+            for path in paths
+        }
+        findings = []
+        for job in concurrent.futures.as_completed(todo):
+            data = job.result()
+            findings.extend(data)
+    if msgid:
+        # select findings by msgid
+        findings = protoerror.select_findings(findings, msgid=msgid)
+    result = protoerror.bypage(findings)
+    return result
+
+
+def iter_findings(path: str):
+    files = utilo.file_list(path, include='yaml', recursive=True)
+    files = [item for item in files if utilo.file_name(item).endswith('_user')]
+    for item in files:
+        location = os.path.join(path, item)
+        findings = serializeraw.load_findings(location)
+        yield location, findings
+
+
+def hash_finding(item):
+    try:
+        return hash(item)
+    except TypeError as error:
+        utilo.error(f'could not hash finding: {item}')
+        raise error
+
+
+def make_finding_number_unique(path: str, private: bool = False) -> bool:
+    """Collect all findings from path and replace with unqiue finding
+    number.
+
+    Note: Remove lintings with equal hash cause there seem/must to be
+          equal.
+
+    Args:
+        path(str): location where files wither user linter are located
+        private(bool): encrypt result
+    Returns:
+        True if some file was located and replace.
+        False if no user file is in `path`.
+    """
+    assert os.path.isdir(path), str(path)
+    single = utilo.Single()
+    replaced = False
+    for location, findings in iter_findings(path):
+        for finding in findings:
+            hashed = hash_finding(finding)
+            if single.contains(hashed):
+                utilo.error(f'duplicated finding: {finding}')
+                finding.number = None  # None -> do not dump this finding
+                continue
+            finding.number = hashed
+        findings = [item for item in findings if item.number is not None]
+        # TODO: REFACTOR LATER
+        dumped = serializeraw.dump_findings(findings)
+        utilo.file_replace(location, dumped, private=private)
+        replaced = True
+    return replaced
+
+
+def finding_status_update(
+    path: str,
+    number: int,
+    status: iamraw.ProblemStatus,
+    private: bool = False,
+) -> bool:
+    assert os.path.isdir(path), str(path)
+    assert isinstance(number, int), type(number)
+    assert isinstance(status, iamraw.ProblemStatus), type(status)
+    # TODO: IMPROVE SPEED LATER? MAY USE A BUFFERED OBJECT ORIENTED APPROACH
+    for location, findings in iter_findings(path):
+        for finding in findings:
+            if finding.number != number:
+                continue
+            if finding.solution is None:
+                utilo.error(f'could not update status: {finding}')
+                return False
+            finding.solution.status = status
+            dumped = serializeraw.dump_findings(findings)
+            utilo.debug(f'number: {number}; status: {status};\n'
+                        f'update: {location}')
+            utilo.file_replace(location, dumped, private=private)
+            return True
+    return False
+
+
+def finding_status(path: str, number: int) -> iamraw.ProblemStatus:
+    assert os.path.isdir(path), str(path)
+    assert isinstance(number, int), type(number)
+    for _, findings in iter_findings(path):
+        for finding in findings:
+            if finding.number != number:
+                continue
+            if finding.solution is None:
+                utilo.error(f'could not get status: {finding}')
+                return None
+            return finding.solution.status
+    return None

protoerror/group.py

@@ -0,0 +1,158 @@
+# =============================================================================
+# C O P Y R I G H T
+# -----------------------------------------------------------------------------
+# Copyright (c) 2019-2022 by Helmut Konrad Fahrendholz. All rights reserved.
+# This file is property of Helmut Konrad Fahrendholz. Any unauthorized copy,
+# use or distribution is an offensive act against international law and may
+# be prosecuted under federal law. Its content is company confidential.
+# =============================================================================
+
+import collections
+import contextlib
+
+import iamraw
+import utilo
+
+import protoerror
+
+
+def bypage(items: iamraw.Findings) -> iamraw.PageFindings:
+    """Group `items` by location.page of `Finding`. Sort the groups
+    ascending by page number."""
+    pages = collections.defaultdict(list)
+    for item in items:
+        assert item.location is not None, f'require location {item}'
+        pages[item.location.page].append(item)
+    result = [
+        iamraw.PageFinding(page=page, content=pages[page])
+        for page in sorted(pages.keys())
+    ]
+    return result
+
+
+def byid(items: iamraw.Findings) -> dict:
+    """Group findings by `finding.msgid`."""
+    grouped = collections.defaultdict(list)
+    for item in items:
+        grouped[item.msgid].append(item)
+    result = dict(grouped)
+    return result
+
+
+def filter_mark(items: iamraw.Findings, shortcut: str) -> iamraw.Findings:
+    """Filter `Findings` by shortcut and sort them by `location.value`
+    afterwards.
+
+    Args:
+        items(iamraw.Findings): list of findings
+        shortcut(str): shortcut of protoerror.location, w word, p page,
+                       ol oneline, etc.
+    Returns:
+        filtered, sorted list of `Findings`
+    """
+    for item in items:
+        if item.location:
+            continue
+        utilo.error(f'missing location: {item}')
+    items = [finding for finding in items if finding.location]
+    selected = []
+    for item in items:
+        with contextlib.suppress(AttributeError):
+            if not isinstance(value(item.location), int):
+                utilo.debug(f'invalid location: {item.location}, require int.')
+                continue
+            if item.location.shortcut == shortcut:
+                selected.append(item)
+    selected.sort(key=lambda x: value(x.location))
+    return selected
+
+
+def value(location) -> int:
+    with contextlib.suppress(AttributeError):
+        if location.value is not None:
+            return location.value
+    with contextlib.suppress(AttributeError):
+        if location.line is not None:
+            return location.line
+    if location.page is not None:
+        return location.page
+    return utilo.INF
+
+
+def words(items: iamraw.Findings) -> iamraw.Findings:
+    return filter_mark(items, shortcut='w')
+
+
+def lines(items: iamraw.Findings) -> iamraw.Findings:
+    return filter_mark(items, shortcut='ol')
+
+
+def sentences(items: iamraw.Findings) -> iamraw.Findings:
+    return filter_mark(items, shortcut='s')
+
+
+def ranged(items: iamraw.Findings) -> iamraw.Findings:
+    return protoerror.filter_mark(items, shortcut='r')
+
+
+def select_findings(
+    findings: iamraw.Findings,
+    msgid: set,
+) -> iamraw.Findings:
+    """Select `Findings` specified by `msgid`
+
+    >>> select_findings([iamraw.Finding(msgid=1337), iamraw.Finding(msgid=1338)], msgid=(1337,1400))
+    [Finding(...msgid=1337...)]
+    >>> select_findings([iamraw.Finding(msgid=1337), iamraw.Finding(msgid=1338)], msgid=1337)
+    [Finding(...msgid=1337...)]
+    """
+    assert all(isinstance(item, iamraw.Finding) for item in findings)
+    if msgid is None:
+        return findings
+    if isinstance(msgid, int):
+        msgid = {msgid}
+    elif isinstance(msgid, list):
+        msgid = set(msgid)
+    return [item for item in findings if item.msgid in msgid]
+
+
+def count_findings(findings: iamraw.Findings, msgid: set) -> int:
+    counted = len(select_findings(findings, msgid))
+    return counted
+
+
+def select_pages(
+    findings: iamraw.Findings,
+    pages: int,
+) -> iamraw.Findings:
+    if pages is None:
+        return findings
+    pages = {pages} if isinstance(pages, int) else pages
+    findings = flat(findings)
+    findings = [
+        finding for finding in findings
+        if finding.location and finding.location.page in pages
+    ]
+    return findings
+
+
+def flat(pages: iamraw.PageFinding) -> list:
+    result = []
+    for page in pages:
+        try:
+            # PageFinding
+            result.extend(page.content)
+        except AttributeError:
+            # findings are already flat
+            result.append(page)
+    return result
+
+
+def select(
+    findings: iamraw.Findings,
+    pages: int,
+    msgid: set,
+) -> iamraw.Findings:
+    findings = select_pages(findings, pages=pages)
+    findings = select_findings(findings, msgid=msgid)
+    return findings