omlish 0.0.0.dev406__py3-none-any.whl → 0.0.0.dev407__py3-none-any.whl

omlish/.manifests.json

@@ -181,7 +181,7 @@
     "module": ".formats.yaml",
     "attr": "_YAML_LAZY_CODEC",
     "file": "omlish/formats/yaml.py",
-    "line": 255,
+    "line": 256,
     "value": {
       "!.codecs.base.LazyLoadedCodec": {
         "module": "omlish.formats.yaml",
@@ -197,7 +197,7 @@
     "module": ".formats.yaml",
     "attr": "_YAML_UNSAFE_LAZY_CODEC",
     "file": "omlish/formats/yaml.py",
-    "line": 262,
+    "line": 263,
     "value": {
       "!.codecs.base.LazyLoadedCodec": {
         "module": "omlish.formats.yaml",

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev406'
-__revision__ = '0862d2e5f3852ab4290573b9bea974cf1e8103a3'
+__version__ = '0.0.0.dev407'
+__revision__ = '069daca807ba62f298b1fef1de82247d29c345c0'
 
 
 #

omlish/asyncs/anyio/sync.py

@@ -14,6 +14,7 @@ T = ta.TypeVar('T')
 class Once:
     def __init__(self) -> None:
         super().__init__()
+
         self._done = False
         self._lock = anyio.Lock()
 
@@ -36,6 +37,7 @@ class Once:
 class Lazy(ta.Generic[T]):
     def __init__(self) -> None:
         super().__init__()
+
         self._once = Once()
         self._v: lang.Maybe[T] = lang.empty()
 
@@ -55,6 +57,7 @@ class Lazy(ta.Generic[T]):
 class LazyFn(ta.Generic[T]):
     def __init__(self, fn: ta.Callable[[], ta.Awaitable[T]]) -> None:
         super().__init__()
+
         self._fn = fn
         self._once = Once()
         self._v: lang.Maybe[T] = lang.empty()

omlish/asyncs/bluelet/runner.py

@@ -62,6 +62,7 @@ from .events import WaitableBlueletEvent
 class BlueletCoroException(Exception):  # noqa
     def __init__(self, coro: BlueletCoro, exc_info: BlueletExcInfo) -> None:
         super().__init__()
+
         self.coro = coro
         self.exc_info = exc_info
 

omlish/asyncs/bluelet/sockets.py

@@ -33,6 +33,7 @@ class BlueletListener:
         """Create a listening socket on the given hostname and port."""
 
         super().__init__()
+
         self._closed = False
         self.host = host
         self.port = port
@@ -64,6 +65,7 @@ class BlueletConnection:
 
     def __init__(self, sock: socket.socket, addr: ta.Tuple[str, int]) -> None:
         super().__init__()
+
         self.sock = sock
         self.addr = addr
         self._buf = bytearray()

omlish/asyncs/sync.py

@@ -60,6 +60,7 @@ async def async_list(fn: ta.Callable[..., ta.AsyncIterator[T]], *args, **kwargs)
 class SyncableIterable(ta.Generic[T]):
     def __init__(self, obj) -> None:
         super().__init__()
+
         self._obj = obj
 
     def __iter__(self) -> ta.Iterator[T]:

omlish/bootstrap/base.py

@@ -18,10 +18,12 @@ class Bootstrap(abc.ABC, lang.PackageSealed, ta.Generic[BootstrapConfigT]):
 
     def __init__(self, config: BootstrapConfigT) -> None:
         super().__init__()
+
         self._config = config
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
+
         if not cls.__name__.endswith('Bootstrap'):
             raise NameError(cls)
         if abc.ABC not in cls.__bases__ and not issubclass(cls.__dict__['Config'], Bootstrap.Config):

omlish/bootstrap/harness.py

@@ -51,6 +51,7 @@ BOOTSTRAP_TYPES_BY_CONFIG_TYPE: ta.Mapping[ta.Type[Bootstrap.Config], ta.Type[Bo
 class BootstrapHarness:
     def __init__(self, lst: ta.Sequence[Bootstrap]) -> None:
         super().__init__()
+
         self._lst = lst
 
     @contextlib.contextmanager

omlish/codecs/text.py

@@ -69,6 +69,7 @@ class TextEncodingComboCodec(ComboCodec[str, bytes]):
             options: TextEncodingOptions = TextEncodingOptions(),
     ) -> None:
         super().__init__()
+
         self._info = check.isinstance(info, codecs.CodecInfo)
         self._opts = check.isinstance(options, TextEncodingOptions)
 

omlish/collections/frozen.py

@@ -26,6 +26,7 @@ class FrozenDict(ta.Mapping[K, V], Frozen):
 
     def __init__(self, *args, **kwargs):
         super().__init__()
+
         self._hash = None
         if len(args) > 1:
             raise TypeError(args)

omlish/collections/mappings.py

@@ -130,7 +130,9 @@ class MissingDict(dict[K, V]):
     def __init__(self, missing_fn: ta.Callable[[K], V]) -> None:
         if not callable(missing_fn):
             raise TypeError(missing_fn)
+
         super().__init__()
+
         self._missing_fn = missing_fn
 
     def __missing__(self, key):

omlish/collections/ordered.py

@@ -10,6 +10,7 @@ T = ta.TypeVar('T')
 class OrderedSet(ta.MutableSet[T]):
     def __init__(self, iterable: ta.Iterable[T] | None = None) -> None:
         super().__init__()
+
         self._dct: dict[T, ta.Any] = {}
         if iterable is not None:
             self |= iterable  # type: ignore  # noqa

omlish/collections/sorted/sorted.py

@@ -121,6 +121,7 @@ class SortedListDict(SortedMutableMapping[K, V]):
 
     def __init__(self, impl: SortedCollection, *args, **kwargs) -> None:
         super().__init__()
+
         self._impl = impl
         for k, v in lang.yield_dict_init(*args, **kwargs):
             self[k] = v

omlish/collections/trie.py

@@ -144,7 +144,7 @@ class Trie(ta.MutableMapping[ta.Sequence[K], V], ta.Generic[K, V]):
             stack.append((c, ic(c._children)))  # noqa
             yield (key if share_key else tuple(key), c)
 
-    def iter_items(self, **kwargs: ta.Any) -> ta.Iterator[tuple[ta.Sequence[K], V]]:
+    def iteritems(self, **kwargs: ta.Any) -> ta.Iterator[tuple[ta.Sequence[K], V]]:
         for k, node in self.iter_nodes(**kwargs):
             try:
                 yield (k, node._value)  # noqa
@@ -152,5 +152,5 @@ class Trie(ta.MutableMapping[ta.Sequence[K], V], ta.Generic[K, V]):
                 pass
 
     def __iter__(self) -> ta.Iterator[ta.Sequence[K]]:
-        for k, _ in self.iter_items():
+        for k, _ in self.iteritems():
             yield k

omlish/concurrent/executors.py

@@ -13,6 +13,7 @@ P = ta.ParamSpec('P')
 class ImmediateExecutor(cf.Executor):
     def __init__(self, *, immediate_exceptions: bool = False) -> None:
         super().__init__()
+
         self._immediate_exceptions = immediate_exceptions
 
     def submit(

omlish/dataclasses/tools/modifiers.py

@@ -20,6 +20,7 @@ T = ta.TypeVar('T')
 class field_modifier:  # noqa
     def __init__(self, fn: ta.Callable[[dc.Field], dc.Field]) -> None:
         super().__init__()
+
         self.fn = fn
 
     def __ror__(self, other: T) -> T:

omlish/diag/threads.py

@@ -52,6 +52,7 @@ class StoppableThread:
             **kwargs: ta.Any,
     ) -> None:
         super().__init__()
+
         self._fn = fn
         self._interval_s = interval_s
         self._tick_immediately = tick_immediately

omlish/formats/dotenv.py

@@ -66,6 +66,7 @@ class DotenvAtom(metaclass=abc.ABCMeta):
 class DotenvLiteral(DotenvAtom):
     def __init__(self, value: str) -> None:
         super().__init__()
+
         self.value = value
 
     def __repr__(self) -> str:
@@ -86,6 +87,7 @@ class DotenvLiteral(DotenvAtom):
 class DotenvVariable(DotenvAtom):
     def __init__(self, name: str, default: ta.Optional[str]) -> None:
         super().__init__()
+
         self.name = name
         self.default = default
 
@@ -164,6 +166,7 @@ class DotenvBinding(ta.NamedTuple):
 class _DotenvPosition:
     def __init__(self, chars: int, line: int) -> None:
         super().__init__()
+
         self.chars = chars
         self.line = line
 
@@ -187,6 +190,7 @@ class DotenvError(Exception):
 class _DotenvReader:
     def __init__(self, stream: ta.IO[str]) -> None:
         super().__init__()
+
         self.string = stream.read()
         self.position = _DotenvPosition.start()
         self.mark = _DotenvPosition.start()
@@ -334,6 +338,7 @@ class Dotenv:
         log: ta.Optional[logging.Logger] = None,
     ) -> None:
         super().__init__()
+
         self.path: ta.Union[str, 'os.PathLike[str]', None] = path
         self.stream: ta.Optional[ta.IO[str]] = stream
         self._dict: ta.Optional[ta.Dict[str, ta.Optional[str]]] = None

omlish/formats/props.py

@@ -129,6 +129,7 @@ class PropertyError(Exception):
 class ParseError(PropertyError):
     def __init__(self, message: str, line_number: int, file_obj: ta.Any = None) -> None:
         super().__init__()
+
         self.message = message
         self.line_number = line_number
         self.file_obj = file_obj

omlish/formats/toml/writer.py

@@ -15,6 +15,7 @@ class TomlWriter:
 
     def __init__(self, out: ta.TextIO) -> None:
         super().__init__()
+
         self._out = out
 
         self._indent = 0

omlish/formats/yaml.py

@@ -134,6 +134,7 @@ class NodeWrappingConstructorMixin:
 class _cached_class_property:  # noqa
     def __init__(self, fn):
         super().__init__()
+
         self._fn = fn
         self._attr = None
 

omlish/funcs/pipes.py

@@ -39,6 +39,7 @@ class Fn(abc.ABC, ta.Generic[T]):
 class Bind(Fn[T]):
     def __init__(self, fn: ta.Callable[..., T], *args: ta.Any, **kwargs: ta.Any) -> None:
         super().__init__()
+
         if Ellipsis not in args and Ellipsis not in kwargs:
             args += (Ellipsis,)
         self._fn = fn
@@ -75,6 +76,7 @@ bind = Bind
 class Pipe(Fn[T]):
     def __init__(self, lfns: ta.Sequence[ta.Callable], rfn: ta.Callable[..., T]) -> None:
         super().__init__()
+
         self._lfn, *self._rfns = [*lfns, rfn]
 
     def __call__(self, *args: ta.Any, **kwargs: ta.Any) -> T:
@@ -95,6 +97,7 @@ def pipe(*fns: ta.Callable) -> Pipe:
 class Apply(Fn[T]):
     def __init__(self, *fns: ta.Callable[[T], ta.Any]) -> None:
         super().__init__()
+
         self._fns = fns
 
     def __call__(self, o: T) -> T:  # noqa

omlish/graphs/trees.py

@@ -26,6 +26,7 @@ NodeGenerator: ta.TypeAlias = ta.Generator[NodeT]
 class NodeError(Exception, ta.Generic[NodeT]):
     def __init__(self, node: NodeT, msg: str, *args, **kwargs) -> None:
         super().__init__(msg, *args, **kwargs)  # noqa
+
         self._node = node
 
     @property

omlish/http/jwt.py

@@ -52,6 +52,7 @@ class Algorithm(abc.ABC):
 class HmacAlgorithm(Algorithm):
     def __init__(self, name: str, digest: ta.Any) -> None:
         super().__init__()
+
         self._name = name
         self._digest = digest
 
@@ -69,6 +70,7 @@ class HmacAlgorithm(Algorithm):
 class RsaAlgorithm(Algorithm):
     def __init__(self, name: str, digest: str) -> None:
         super().__init__()
+
         self._name = name
         self._digest = digest
 

omlish/http/multipart.py

@@ -31,6 +31,7 @@ class MultipartEncoder:
             boundary: bytes | None = None,
     ) -> None:
         super().__init__()
+
         self._fields = fields
         self._boundary = boundary or (b'----WebKitFormBoundary-' + uuid.uuid4().hex.encode('ascii'))
 

omlish/inject/impl/injector.py

@@ -111,6 +111,7 @@ class InjectorImpl(Injector, lang.Final):
     class _Request:
         def __init__(self, injector: 'InjectorImpl') -> None:
             super().__init__()
+
             self._injector = injector
             self._provisions: dict[Key, lang.Maybe] = {}
             self._seen_keys: set[Key] = set()

omlish/io/buffers.py

@@ -24,6 +24,7 @@ class DelimitingBuffer:
     class Error(Exception):
         def __init__(self, buffer: 'DelimitingBuffer') -> None:
             super().__init__(buffer)
+
             self.buffer = buffer
 
         def __repr__(self) -> str:
@@ -179,6 +180,7 @@ class ReadableListBuffer:
 
     def __init__(self) -> None:
         super().__init__()
+
         self._lst: list[bytes] = []
 
     def __len__(self) -> int:

omlish/iterators/unique.py

@@ -33,6 +33,7 @@ class UniqueIterator(ta.Iterator[UniqueItem[T]]):
             keyer: ta.Callable[[T], ta.Any] = lang.identity,
     ) -> None:
         super().__init__()
+
         self._it = enumerate(it)
         self._keyer = keyer
 

omlish/lang/classes/restrict.py

@@ -129,6 +129,7 @@ class NoBool:
 class _NoBoolDescriptor:
     def __init__(self, fn, instance=None, owner=None) -> None:
         super().__init__()
+
         self._fn = fn
         self._instance = instance
         self._owner = owner

omlish/lang/classes/simple.py

@@ -91,6 +91,7 @@ class Singleton:
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
+
         _set_singleton_instance(super().__new__(cls))  # noqa
 
 

omlish/lang/contextmanagers.py

@@ -266,6 +266,7 @@ class Timer:
             clock: ta.Callable[[], float] | None = None,
     ) -> None:
         super().__init__()
+
         self._clock = clock if clock is not None else time.monotonic
 
     _start: float

omlish/lang/descriptors.py

@@ -200,6 +200,7 @@ decorator = _decorator
 class AccessForbiddenError(Exception):
     def __init__(self, name: str | None = None, *args: ta.Any, **kwargs: ta.Any) -> None:
         super().__init__(*((name,) if name is not None else ()), *args, **kwargs)  # noqa
+
         self.name = name
 
 
@@ -231,6 +232,7 @@ class _ClassOnly:
         if not isinstance(mth, classmethod):
             raise TypeError(f'must be classmethod: {mth}')
         super().__init__()
+
         self._mth = (mth,)
         functools.update_wrapper(self, mth)  # type: ignore
 

omlish/lang/objects.py

@@ -166,6 +166,7 @@ class SimpleProxy(ta.Generic[T]):
     class Descriptor:
         def __init__(self, attr: str) -> None:
             super().__init__()
+
             self._attr = attr
 
         def __get__(self, instance, owner=None):
@@ -189,6 +190,7 @@ class SimpleProxy(ta.Generic[T]):
 
     def __init__(self, wrapped: T) -> None:
         super().__init__()
+
         object.__setattr__(self, '__wrapped__', wrapped)
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:

omlish/lang/resolving.py

@@ -59,4 +59,5 @@ def get_fqcn_cls(fqcn: str, *, nocheck: bool = False) -> type:
 class Resolvable:
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
+
         get_cls_fqcn(cls, nocheck=True)

omlish/lifecycles/contextmanagers.py

@@ -33,6 +33,7 @@ class ContextManagerLifecycle(Lifecycle, lang.Final, ta.Generic[ContextManagerT]
 class LifecycleContextManager(ta.Generic[LifecycleT]):
     def __init__(self, lifecycle: LifecycleT) -> None:
         super().__init__()
+
         self._lifecycle = lifecycle
         self._controller = lifecycle if isinstance(lifecycle, LifecycleController) else LifecycleController(lifecycle)
 

omlish/lite/cached.py

@@ -13,6 +13,7 @@ CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 class _AbstractCachedNullary:
     def __init__(self, fn):
         super().__init__()
+
         self._fn = fn
         self._value = self._missing = object()
         functools.update_wrapper(self, fn)

omlish/lite/inject.py

@@ -402,6 +402,7 @@ class ContextvarInjectorScope(InjectorScope, abc.ABC):
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
+
         check.not_in(abc.ABC, cls.__bases__)
         check.state(not hasattr(cls, '_cv'))
         cls._cv = contextvars.ContextVar(f'{cls.__name__}_cv')
@@ -676,6 +677,7 @@ class _Injector(Injector):
     class _Request:
         def __init__(self, injector: '_Injector') -> None:
             super().__init__()
+
             self._injector = injector
             self._provisions: ta.Dict[InjectorKey, Maybe] = {}
             self._seen_keys: ta.Set[InjectorKey] = set()

omlish/lite/secrets.py

@@ -12,6 +12,7 @@ class Secret:
 
     def __init__(self, *, key: ta.Optional[str] = None, value: str) -> None:
         super().__init__()
+
         self._key = key
         setattr(self, self._VALUE_ATTR, lambda: value)
 

omlish/logs/handlers.py

@@ -10,6 +10,7 @@ import typing as ta
 class ListHandler(logging.Handler):
     def __init__(self) -> None:
         super().__init__()
+
         self.records: ta.List[logging.LogRecord] = []
 
     def emit(self, record: logging.LogRecord) -> None:

omlish/marshal/factories.py

@@ -41,6 +41,7 @@ class TypeMapFactory(mfs.MatchFn[[C, rfl.Type], R]):
 class TypeCacheFactory(mfs.MatchFn[[C, rfl.Type], R]):
     def __init__(self, f: mfs.MatchFn[[C, rfl.Type], R]) -> None:
         super().__init__()
+
         self._f = f
         self._dct: dict[rfl.Type, R | None] = {}
         self._mtx = threading.RLock()
@@ -90,6 +91,7 @@ class RecursiveTypeFactory(mfs.MatchFn[[C, rfl.Type], R]):
             prx: ta.Callable[[], tuple[R, ta.Callable[[R], None]]],
     ) -> None:
         super().__init__()
+
         self._f = f
         self._prx = prx
         self._dct: dict[rfl.Type, R] = {}

omlish/marshal/polymorphism/metadata.py

@@ -39,6 +39,7 @@ class Impls(ta.Sequence[Impl]):
             lst: ta.Iterable[Impl],
     ) -> None:
         super().__init__()
+
         self._lst = list(lst)
 
         by_ty: dict[type, Impl] = {}
@@ -89,6 +90,7 @@ class Polymorphism:
             impls: ta.Iterable[Impl],
     ) -> None:
         super().__init__()
+
         self._ty = ty
         self._impls = Impls(impls)
 

omlish/marshal/registries.py

@@ -35,6 +35,7 @@ class _KeyRegistryItems:
 class Registry:
     def __init__(self) -> None:
         super().__init__()
+
         self._mtx = threading.Lock()
         self._idct: ta.MutableMapping[ta.Any, _KeyRegistryItems] = col.IdentityKeyDict()
         self._dct: dict[ta.Any, _KeyRegistryItems] = {}

omlish/multiprocessing/spawn.py

@@ -24,6 +24,7 @@ class ExtrasSpawnPosixPopen(mp.popen_spawn_posix.Popen):
     def __init__(self, process_obj: 'ExtrasSpawnProcess', *, extras: SpawnExtras) -> None:
         self.__extras = extras
         self.__pass_fds = extras.pass_fds
+
         super().__init__(process_obj)
 
     def _launch(self, process_obj: 'ExtrasSpawnProcess') -> None:
@@ -38,6 +39,7 @@ class ExtrasSpawnPosixPopen(mp.popen_spawn_posix.Popen):
 class ExtrasSpawnProcess(mp.context.SpawnProcess):
     def __init__(self, *args: ta.Any, extras: SpawnExtras, **kwargs: ta.Any) -> None:
         self.__extras = extras
+
         super().__init__(*args, **kwargs)
 
     def _Popen(self, process_obj: 'ExtrasSpawnProcess') -> ExtrasSpawnPosixPopen:  # type: ignore  # noqa
@@ -56,6 +58,7 @@ class ExtrasSpawnProcess(mp.context.SpawnProcess):
 class ExtrasSpawnContext(mp.context.SpawnContext):
     def __init__(self, extras: SpawnExtras = SpawnExtras()) -> None:
         self.__extras = extras
+
         super().__init__()
 
     def Process(self, *args: ta.Any, **kwargs: ta.Any):  # type: ignore  # noqa

omlish/secrets/openssl.py

@@ -56,6 +56,7 @@ class OpensslAescbcCrypto(Crypto):
             iters: int = 10_000,
     ) -> None:
         super().__init__()
+
         self._iters = iters
 
     def generate_key(self, sz: int = DEFAULT_KEY_SIZE) -> bytes:
@@ -131,6 +132,7 @@ class OpensslSubprocessAescbcCrypto(Crypto):
             file_input: SubprocessFileInputMethod = temp_subprocess_file_input,
     ) -> None:
         super().__init__()
+
         self._cmd = cmd
         self._timeout = timeout
         self._file_input = file_input

omlish/secrets/secrets.py

@@ -33,6 +33,7 @@ class Secret(lang.NotPicklable, lang.Sensitive, lang.Final):
 
     def __init__(self, *, key: str | None, value: str) -> None:
         super().__init__()
+
         self._key = key
         setattr(self, self._VALUE_ATTR, lambda: value)
 
@@ -203,6 +204,7 @@ class CachingSecrets(Secrets):
             clock: ta.Callable[..., float] = time.time,
     ) -> None:
         super().__init__()
+
         self._child = child
         self._dct: dict[str, Secret] = {}
         self._ttl_s = ttl_s
@@ -243,6 +245,7 @@ class CachingSecrets(Secrets):
 class CompositeSecrets(Secrets):
     def __init__(self, *children: Secrets) -> None:
         super().__init__()
+
         self._children = children
 
     def _get_raw(self, key: str) -> str:
@@ -265,6 +268,7 @@ class LoggingSecrets(Secrets):
             log: logging.Logger | None = None,  # noqa
     ) -> None:
         super().__init__()
+
         self._child = child
         self._log = log if log is not None else globals()['log']
 
@@ -317,6 +321,7 @@ class EnvVarSecrets(Secrets):
             pop: bool = False,
     ) -> None:
         super().__init__()
+
         self._env = env
         self._upcase = upcase
         self._prefix = prefix

omlish/specs/jmespath/errors.py

@@ -19,6 +19,7 @@ class ParseError(JmespathError):
             msg: str = _ERROR_MESSAGE,
     ) -> None:
         super().__init__(lex_position, token_value, token_type)
+
         self.lex_position = lex_position
         self.token_value = token_value
         self.token_type = token_type.upper()
@@ -56,7 +57,9 @@ class LexerError(ParseError):
         self.lexer_position = lexer_position
         self.lexer_value = lexer_value
         self.message = message
+
         super().__init__(lexer_position, lexer_value, message)
+
         # Whatever catches LexerError can set this.
         self.expression = expression
 
@@ -143,4 +146,5 @@ class UnknownFunctionError(JmespathError):
 class UndefinedVariableError(JmespathError):
     def __init__(self, varname):
         self.varname = varname
+
         super().__init__(f'Reference to undefined variable: {self.varname}')

omlish/specs/jmespath/visitor.py

@@ -164,6 +164,7 @@ class Options:
 class _Expression:
     def __init__(self, expression: Node, interpreter: 'TreeInterpreter') -> None:
         super().__init__()
+
         self.expression = expression
         self.interpreter = interpreter
 
@@ -487,6 +488,7 @@ class TreeInterpreter(Visitor):
 class GraphvizVisitor:
     def __init__(self) -> None:
         super().__init__()
+
         self._lines: list[str] = []
         self._count = 1
 

omlish/specs/jsonschema/keywords/base.py

@@ -34,6 +34,7 @@ class KnownKeyword(Keyword, lang.Abstract):
             **kwargs: ta.Any,
     ) -> None:
         super().__init_subclass__(**kwargs)
+
         check.empty(set(dir(cls)) & {'tag', 'aliases', 'tag_and_aliases'})
         if not lang.is_abstract_class(cls):
             check.issubclass(cls, lang.Final)