From 2253e2bb002bd1e863a50345085a05132d623d12 Mon Sep 17 00:00:00 2001 From: linuxdaemon Date: Wed, 3 Apr 2024 16:49:46 +0000 Subject: [PATCH] Apply linting config --- polymatch/__init__.py | 4 +-- polymatch/base.py | 54 ++++++++++++++++++++++++++++--------- polymatch/error.py | 17 +++++++++--- polymatch/matchers/glob.py | 4 +-- polymatch/matchers/regex.py | 4 +-- polymatch/registry.py | 28 ++++++++++++------- tests/test_glob.py | 2 ++ tests/test_pickling.py | 25 ++++++++++------- tests/test_regex.py | 2 ++ tests/test_standard.py | 2 ++ 10 files changed, 102 insertions(+), 40 deletions(-) diff --git a/polymatch/__init__.py b/polymatch/__init__.py index 5229f41..a0c1580 100644 --- a/polymatch/__init__.py +++ b/polymatch/__init__.py @@ -1,9 +1,9 @@ -from .base import PolymorphicMatcher, CaseAction from . import error +from .base import CaseAction, PolymorphicMatcher from .error import * from .registry import pattern_registry __version__ = "0.2.0" -__all__ = ("PolymorphicMatcher","CaseAction", "pattern_registry") +__all__ = ("PolymorphicMatcher", "CaseAction", "pattern_registry") __all__ += error.__all__ diff --git a/polymatch/base.py b/polymatch/base.py index 13699a3..38ecf8f 100644 --- a/polymatch/base.py +++ b/polymatch/base.py @@ -2,14 +2,18 @@ from enum import Enum import polymatch -from polymatch.error import PatternCompileError, PatternNotCompiledError, PatternTextTypeMismatchError +from polymatch.error import ( + PatternCompileError, + PatternNotCompiledError, + PatternTextTypeMismatchError, +) class CaseAction(Enum): - NONE = 'none', '' # Use whatever the pattern's default is - CASESENSITIVE = 'case-sensitive', 'cs' # Fore case sensitivity - CASEINSENSITIVE = 'case-insensitive', 'ci' # Force case insensitivity - CASEFOLD = 'casefold', 'cf' # Force case-folded comparison + NONE = "none", "" # Use whatever the pattern's default is + CASESENSITIVE = "case-sensitive", "cs" # Fore case sensitivity + CASEINSENSITIVE = "case-insensitive", "ci" # Force case insensitivity + CASEFOLD = "casefold", "cf" # Force case-folded comparison class PolymorphicMatcher(metaclass=ABCMeta): @@ -39,7 +43,9 @@ def compile(self): try: self._compiled_pattern = self._compile_func(self._raw_pattern) except Exception as e: - raise PatternCompileError("Failed to compile pattern {!r}".format(self._raw_pattern)) from e + raise PatternCompileError( + f"Failed to compile pattern {self._raw_pattern!r}" + ) from e def __eq__(self, other): if isinstance(other, self._str_type): @@ -107,9 +113,11 @@ def _get_case_functions(self): suffix = self._case_action.value[1] if suffix: - suffix = '_' + suffix + suffix = "_" + suffix - return getattr(self, "compile_pattern" + suffix), getattr(self, "match_text" + suffix) + return getattr(self, "compile_pattern" + suffix), getattr( + self, "match_text" + suffix + ) @classmethod @abstractmethod @@ -130,17 +138,30 @@ def inverted(self): def __str__(self): return "{}{}:{}:{}".format( - '~' if self._invert else '', self.get_type(), self._case_action.value[1], self._raw_pattern + "~" if self._invert else "", + self.get_type(), + self._case_action.value[1], + self._raw_pattern, ) def __repr__(self): return "{}(pattern={!r}, case_action={!r}, invert={!r})".format( - type(self).__name__, self._raw_pattern, self._case_action, self._invert + type(self).__name__, + self._raw_pattern, + self._case_action, + self._invert, ) def __getstate__(self): - return polymatch.__version__, self._raw_pattern, self._case_action, self._invert, self._compiled_pattern, \ - self._str_type, self._empty + return ( + polymatch.__version__, + self._raw_pattern, + self._case_action, + self._invert, + self._compiled_pattern, + self._str_type, + self._empty, + ) def __setstate__(self, state): if len(state) > 6: @@ -148,7 +169,14 @@ def __setstate__(self, state): else: version = "0.0.0" - self._raw_pattern, self._case_action, self._invert, self._compiled_pattern, self._str_type, self._empty = state + ( + self._raw_pattern, + self._case_action, + self._invert, + self._compiled_pattern, + self._str_type, + self._empty, + ) = state self._compile_func, self._match_func = self._get_case_functions() if version != polymatch.__version__ and self.is_compiled(): diff --git a/polymatch/error.py b/polymatch/error.py index e9fdb4e..ec940d1 100644 --- a/polymatch/error.py +++ b/polymatch/error.py @@ -1,4 +1,13 @@ -__all__ = ("PatternCompileError","PatternNotCompiledError", "PatternTextTypeMismatchError", "DuplicateMatcherRegistrationError", "NoSuchMatcherError", "NoMatchersAvailable") +__all__ = ( + "PatternCompileError", + "PatternNotCompiledError", + "PatternTextTypeMismatchError", + "DuplicateMatcherRegistrationError", + "NoSuchMatcherError", + "NoMatchersAvailable", +) + + class PatternCompileError(ValueError): pass @@ -10,13 +19,15 @@ class PatternNotCompiledError(ValueError): class PatternTextTypeMismatchError(TypeError): def __init__(self, pattern_type, text_type): super().__init__( - "Pattern of type {!r} can not match text of type {!r}".format(pattern_type.__name__, text_type.__name__) + "Pattern of type {!r} can not match text of type {!r}".format( + pattern_type.__name__, text_type.__name__ + ) ) class DuplicateMatcherRegistrationError(ValueError): def __init__(self, name): - super().__init__("Attempted o register a duplicate matcher {!r}".format(name)) + super().__init__(f"Attempted o register a duplicate matcher {name!r}") class NoSuchMatcherError(LookupError): diff --git a/polymatch/matchers/glob.py b/polymatch/matchers/glob.py index 5c404a4..399d179 100644 --- a/polymatch/matchers/glob.py +++ b/polymatch/matchers/glob.py @@ -7,9 +7,9 @@ class GlobMatcher(RegexMatcher): def compile_pattern(self, raw_pattern, flags=0): if isinstance(raw_pattern, bytes): # Mimic how fnmatch handles bytes patterns - pat_str = str(raw_pattern, 'ISO-8859-1') + pat_str = str(raw_pattern, "ISO-8859-1") res_str = translate(pat_str) - res = bytes(res_str, 'ISO-8859-1') + res = bytes(res_str, "ISO-8859-1") else: res = translate(raw_pattern) diff --git a/polymatch/matchers/regex.py b/polymatch/matchers/regex.py index b4991b1..ab5b3a4 100644 --- a/polymatch/matchers/regex.py +++ b/polymatch/matchers/regex.py @@ -4,14 +4,14 @@ import regex except ImportError as e: try: - _exc = globals()['ModuleNotFoundError'] + _exc = globals()["ModuleNotFoundError"] except LookupError: pass else: if not isinstance(e, _exc): raise - if e.name != 'regex': + if e.name != "regex": raise regex = None diff --git a/polymatch/registry.py b/polymatch/registry.py index b2035ec..ca8d24d 100644 --- a/polymatch/registry.py +++ b/polymatch/registry.py @@ -1,16 +1,20 @@ from collections import OrderedDict -from polymatch.base import PolymorphicMatcher, CaseAction -from polymatch.error import DuplicateMatcherRegistrationError, NoSuchMatcherError, NoMatchersAvailable +from polymatch.base import CaseAction, PolymorphicMatcher +from polymatch.error import ( + DuplicateMatcherRegistrationError, + NoMatchersAvailable, + NoSuchMatcherError, +) from polymatch.matchers.glob import GlobMatcher from polymatch.matchers.regex import RegexMatcher -from polymatch.matchers.standard import ExactMatcher, ContainsMatcher +from polymatch.matchers.standard import ContainsMatcher, ExactMatcher -def _opt_split(text, delim=':', empty="", invchar='~'): +def _opt_split(text, delim=":", empty="", invchar="~"): if text.startswith(invchar): invert = True - text = text[len(invchar):] + text = text[len(invchar) :] else: invert = False @@ -34,10 +38,12 @@ def _parse_pattern_string(text): return invert, name, opts, pattern elif isinstance(text, bytes): - invert, name, opts, pattern = _opt_split(text, b':', b'', b'~') + invert, name, opts, pattern = _opt_split(text, b":", b"", b"~") return invert, name.decode(), opts.decode(), pattern else: - raise TypeError("Unable to parse pattern string of type {!r}".format(type(text).__name__)) + raise TypeError( + f"Unable to parse pattern string of type {type(text).__name__!r}" + ) class PatternMatcherRegistry: @@ -51,7 +57,9 @@ def register(self, cls): if not issubclass(cls, PolymorphicMatcher): raise TypeError( - "Pattern matcher must be of type {!r} not {!r}".format(PolymorphicMatcher.__name__, cls.__name__) + "Pattern matcher must be of type {!r} not {!r}".format( + PolymorphicMatcher.__name__, cls.__name__ + ) ) self._matchers[name] = cls @@ -88,7 +96,9 @@ def pattern_from_string(self, text): break if case_action is None: - raise LookupError("Unable to find CaseAction for options: {!r}".format(opts)) + raise LookupError( + f"Unable to find CaseAction for options: {opts!r}" + ) return match_cls(pattern, case_action, invert) diff --git a/tests/test_glob.py b/tests/test_glob.py index 0b6d917..2d79c27 100644 --- a/tests/test_glob.py +++ b/tests/test_glob.py @@ -8,6 +8,7 @@ def test_patterns(): from polymatch import pattern_registry + for pattern, text, result in data: matcher = pattern_registry.pattern_from_string(pattern) matcher.compile() @@ -16,6 +17,7 @@ def test_patterns(): def test_invert(): from polymatch import pattern_registry + pattern = pattern_registry.pattern_from_string("~glob::beep") pattern.compile() assert pattern.inverted diff --git a/tests/test_pickling.py b/tests/test_pickling.py index 942ed99..4d152ac 100644 --- a/tests/test_pickling.py +++ b/tests/test_pickling.py @@ -14,11 +14,13 @@ def __init__(self, pat): def pytest_generate_tests(metafunc): - if 'pattern' in metafunc.fixturenames: - metafunc.parametrize('pattern', patterns) + if "pattern" in metafunc.fixturenames: + metafunc.parametrize("pattern", patterns) - if 'pickle_proto' in metafunc.fixturenames: - metafunc.parametrize('pickle_proto', list(range(pickle.HIGHEST_PROTOCOL + 1))) + if "pickle_proto" in metafunc.fixturenames: + metafunc.parametrize( + "pickle_proto", list(range(pickle.HIGHEST_PROTOCOL + 1)) + ) def cycle_pickle(obj, proto): @@ -27,6 +29,7 @@ def cycle_pickle(obj, proto): def test_compile_state(pattern, pickle_proto): from polymatch import pattern_registry + compiled_pattern = pattern_registry.pattern_from_string(pattern) compiled_pattern.compile() @@ -36,7 +39,9 @@ def test_compile_state(pattern, pickle_proto): assert not uncompiled_pattern.is_compiled() - pat1, pat2 = cycle_pickle((compiled_pattern, uncompiled_pattern), pickle_proto) + pat1, pat2 = cycle_pickle( + (compiled_pattern, uncompiled_pattern), pickle_proto + ) assert pat1.is_compiled() is compiled_pattern.is_compiled() @@ -45,10 +50,11 @@ def test_compile_state(pattern, pickle_proto): def test_properties(pattern, pickle_proto): from polymatch import pattern_registry + pat = pattern_registry.pattern_from_string(pattern) pat.compile() - inv_pat = pattern_registry.pattern_from_string('~' + pattern) + inv_pat = pattern_registry.pattern_from_string("~" + pattern) inv_pat.compile() assert not pat.inverted @@ -68,8 +74,9 @@ def test_properties(pattern, pickle_proto): def test_version_checks(pattern, pickle_proto): - from polymatch import pattern_registry import polymatch + from polymatch import pattern_registry + pat = pattern_registry.pattern_from_string(pattern) pat.compile() @@ -78,9 +85,9 @@ def test_version_checks(pattern, pickle_proto): data = pickle.dumps(pat, pickle_proto) # Change version - v = polymatch.__version__.split('.') + v = polymatch.__version__.split(".") v[-1] = str(int(v[-1]) + 1) - polymatch.__version__ = '.'.join(v) + polymatch.__version__ = ".".join(v) new_pat = pickle.loads(data) diff --git a/tests/test_regex.py b/tests/test_regex.py index 9194a08..b5f95c5 100644 --- a/tests/test_regex.py +++ b/tests/test_regex.py @@ -8,6 +8,7 @@ def test_patterns(): from polymatch import pattern_registry + for pattern, text, result in data: matcher = pattern_registry.pattern_from_string(pattern) matcher.compile() @@ -16,6 +17,7 @@ def test_patterns(): def test_invert(): from polymatch import pattern_registry + pattern = pattern_registry.pattern_from_string("~regex::beep") pattern.compile() assert pattern.inverted diff --git a/tests/test_standard.py b/tests/test_standard.py index 77b915a..482a294 100644 --- a/tests/test_standard.py +++ b/tests/test_standard.py @@ -9,6 +9,7 @@ def test_patterns(): from polymatch import pattern_registry + for pattern, text, result in data: matcher = pattern_registry.pattern_from_string(pattern) matcher.compile() @@ -17,6 +18,7 @@ def test_patterns(): def test_invert(): from polymatch import pattern_registry + pattern = pattern_registry.pattern_from_string("~exact::beep") pattern.compile() assert pattern.inverted