ominfra 0.0.0.dev149__py3-none-any.whl → 0.0.0.dev150__py3-none-any.whl

ominfra/scripts/journald2aws.py

@@ -7,6 +7,7 @@
 import abc
 import argparse
 import base64
+import collections
 import collections.abc
 import contextlib
 import dataclasses as dc
@@ -62,6 +63,11 @@ CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 
 # ../../../../omlish/lite/check.py
 SizedT = ta.TypeVar('SizedT', bound=ta.Sized)
+CheckMessage = ta.Union[str, ta.Callable[..., ta.Optional[str]], None]  # ta.TypeAlias
+CheckLateConfigureFn = ta.Callable[['Checks'], None]
+CheckOnRaiseFn = ta.Callable[[Exception], None]  # ta.TypeAlias
+CheckExceptionFactory = ta.Callable[..., Exception]  # ta.TypeAlias
+CheckArgsRenderer = ta.Callable[..., ta.Optional[str]]  # ta.TypeAlias
 
 # ../../../../omlish/lite/contextmanagers.py
 ExitStackedT = ta.TypeVar('ExitStackedT', bound='ExitStacked')
@@ -952,104 +958,454 @@ def async_cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
 
 ########################################
 # ../../../../../omlish/lite/check.py
+"""
+TODO:
+ - def maybe(v: lang.Maybe[T])
+ - patch / override lite.check ?
+  - checker interface?
+"""
+
+
+##
+
+
+class Checks:
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._config_lock = threading.RLock()
+        self._on_raise_fns: ta.Sequence[CheckOnRaiseFn] = []
+        self._exception_factory: CheckExceptionFactory = Checks.default_exception_factory
+        self._args_renderer: ta.Optional[CheckArgsRenderer] = None
+        self._late_configure_fns: ta.Sequence[CheckLateConfigureFn] = []
+
+    @staticmethod
+    def default_exception_factory(exc_cls: ta.Type[Exception], *args, **kwargs) -> Exception:
+        return exc_cls(*args, **kwargs)  # noqa
 
+    #
 
-def check_isinstance(v: ta.Any, spec: ta.Union[ta.Type[T], tuple]) -> T:
-    if not isinstance(v, spec):
-        raise TypeError(v)
-    return v
+    def register_on_raise(self, fn: CheckOnRaiseFn) -> None:
+        with self._config_lock:
+            self._on_raise_fns = [*self._on_raise_fns, fn]
 
+    def unregister_on_raise(self, fn: CheckOnRaiseFn) -> None:
+        with self._config_lock:
+            self._on_raise_fns = [e for e in self._on_raise_fns if e != fn]
 
-def check_not_isinstance(v: T, spec: ta.Union[type, tuple]) -> T:
-    if isinstance(v, spec):
-        raise TypeError(v)
-    return v
+    #
 
+    def set_exception_factory(self, factory: CheckExceptionFactory) -> None:
+        self._exception_factory = factory
 
-def check_none(v: T) -> None:
-    if v is not None:
-        raise ValueError(v)
+    def set_args_renderer(self, renderer: ta.Optional[CheckArgsRenderer]) -> None:
+        self._args_renderer = renderer
 
+    #
 
-def check_not_none(v: ta.Optional[T]) -> T:
-    if v is None:
-        raise ValueError
-    return v
+    def register_late_configure(self, fn: CheckLateConfigureFn) -> None:
+        with self._config_lock:
+            self._late_configure_fns = [*self._late_configure_fns, fn]
 
+    def _late_configure(self) -> None:
+        if not self._late_configure_fns:
+            return
 
-def check_not(v: ta.Any) -> None:
-    if v:
-        raise ValueError(v)
-    return v
+        with self._config_lock:
+            if not (lc := self._late_configure_fns):
+                return
 
+            for fn in lc:
+                fn(self)
 
-def check_non_empty_str(v: ta.Optional[str]) -> str:
-    if not v:
-        raise ValueError
-    return v
+            self._late_configure_fns = []
 
+    #
 
-def check_arg(v: bool, msg: str = 'Illegal argument') -> None:
-    if not v:
-        raise ValueError(msg)
+    class _ArgsKwargs:
+        def __init__(self, *args, **kwargs):
+            self.args = args
+            self.kwargs = kwargs
 
+    def _raise(
+            self,
+            exception_type: ta.Type[Exception],
+            default_message: str,
+            message: CheckMessage,
+            ak: _ArgsKwargs = _ArgsKwargs(),
+            *,
+            render_fmt: ta.Optional[str] = None,
+    ) -> ta.NoReturn:
+        exc_args = ()
+        if callable(message):
+            message = ta.cast(ta.Callable, message)(*ak.args, **ak.kwargs)
+            if isinstance(message, tuple):
+                message, *exc_args = message  # type: ignore
+
+        if message is None:
+            message = default_message
+
+        self._late_configure()
+
+        if render_fmt is not None and (af := self._args_renderer) is not None:
+            rendered_args = af(render_fmt, *ak.args)
+            if rendered_args is not None:
+                message = f'{message} : {rendered_args}'
+
+        exc = self._exception_factory(
+            exception_type,
+            message,
+            *exc_args,
+            *ak.args,
+            **ak.kwargs,
+        )
 
-def check_state(v: bool, msg: str = 'Illegal state') -> None:
-    if not v:
-        raise ValueError(msg)
+        for fn in self._on_raise_fns:
+            fn(exc)
 
+        raise exc
 
-def check_equal(l: T, r: T) -> T:
-    if l != r:
-        raise ValueError(l, r)
-    return l
+    #
 
+    def _unpack_isinstance_spec(self, spec: ta.Any) -> tuple:
+        if isinstance(spec, type):
+            return (spec,)
+        if not isinstance(spec, tuple):
+            spec = (spec,)
+        if None in spec:
+            spec = tuple(filter(None, spec)) + (None.__class__,)  # noqa
+        if ta.Any in spec:
+            spec = (object,)
+        return spec
+
+    def isinstance(self, v: ta.Any, spec: ta.Union[ta.Type[T], tuple], msg: CheckMessage = None) -> T:  # noqa
+        if not isinstance(v, self._unpack_isinstance_spec(spec)):
+            self._raise(
+                TypeError,
+                'Must be instance',
+                msg,
+                Checks._ArgsKwargs(v, spec),
+                render_fmt='not isinstance(%s, %s)',
+            )
 
-def check_not_equal(l: T, r: T) -> T:
-    if l == r:
-        raise ValueError(l, r)
-    return l
+        return v
 
+    def of_isinstance(self, spec: ta.Union[ta.Type[T], tuple], msg: CheckMessage = None) -> ta.Callable[[ta.Any], T]:
+        def inner(v):
+            return self.isinstance(v, self._unpack_isinstance_spec(spec), msg)
 
-def check_is(l: T, r: T) -> T:
-    if l is not r:
-        raise ValueError(l, r)
-    return l
+        return inner
 
+    def cast(self, v: ta.Any, cls: ta.Type[T], msg: CheckMessage = None) -> T:  # noqa
+        if not isinstance(v, cls):
+            self._raise(
+                TypeError,
+                'Must be instance',
+                msg,
+                Checks._ArgsKwargs(v, cls),
+            )
 
-def check_is_not(l: T, r: ta.Any) -> T:
-    if l is r:
-        raise ValueError(l, r)
-    return l
+        return v
 
+    def of_cast(self, cls: ta.Type[T], msg: CheckMessage = None) -> ta.Callable[[T], T]:
+        def inner(v):
+            return self.cast(v, cls, msg)
 
-def check_in(v: T, c: ta.Container[T]) -> T:
-    if v not in c:
-        raise ValueError(v, c)
-    return v
+        return inner
 
+    def not_isinstance(self, v: T, spec: ta.Any, msg: CheckMessage = None) -> T:  # noqa
+        if isinstance(v, self._unpack_isinstance_spec(spec)):
+            self._raise(
+                TypeError,
+                'Must not be instance',
+                msg,
+                Checks._ArgsKwargs(v, spec),
+                render_fmt='isinstance(%s, %s)',
+            )
 
-def check_not_in(v: T, c: ta.Container[T]) -> T:
-    if v in c:
-        raise ValueError(v, c)
-    return v
+        return v
 
+    def of_not_isinstance(self, spec: ta.Any, msg: CheckMessage = None) -> ta.Callable[[T], T]:
+        def inner(v):
+            return self.not_isinstance(v, self._unpack_isinstance_spec(spec), msg)
 
-def check_single(vs: ta.Iterable[T]) -> T:
-    [v] = vs
-    return v
+        return inner
 
+    ##
+
+    def issubclass(self, v: ta.Type[T], spec: ta.Any, msg: CheckMessage = None) -> ta.Type[T]:  # noqa
+        if not issubclass(v, spec):
+            self._raise(
+                TypeError,
+                'Must be subclass',
+                msg,
+                Checks._ArgsKwargs(v, spec),
+                render_fmt='not issubclass(%s, %s)',
+            )
+
+        return v
+
+    def not_issubclass(self, v: ta.Type[T], spec: ta.Any, msg: CheckMessage = None) -> ta.Type[T]:  # noqa
+        if issubclass(v, spec):
+            self._raise(
+                TypeError,
+                'Must not be subclass',
+                msg,
+                Checks._ArgsKwargs(v, spec),
+                render_fmt='issubclass(%s, %s)',
+            )
+
+        return v
+
+    #
+
+    def in_(self, v: T, c: ta.Container[T], msg: CheckMessage = None) -> T:
+        if v not in c:
+            self._raise(
+                ValueError,
+                'Must be in',
+                msg,
+                Checks._ArgsKwargs(v, c),
+                render_fmt='%s not in %s',
+            )
+
+        return v
+
+    def not_in(self, v: T, c: ta.Container[T], msg: CheckMessage = None) -> T:
+        if v in c:
+            self._raise(
+                ValueError,
+                'Must not be in',
+                msg,
+                Checks._ArgsKwargs(v, c),
+                render_fmt='%s in %s',
+            )
+
+        return v
+
+    def empty(self, v: SizedT, msg: CheckMessage = None) -> SizedT:
+        if len(v) != 0:
+            self._raise(
+                ValueError,
+                'Must be empty',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v
+
+    def iterempty(self, v: ta.Iterable[T], msg: CheckMessage = None) -> ta.Iterable[T]:
+        it = iter(v)
+        try:
+            next(it)
+        except StopIteration:
+            pass
+        else:
+            self._raise(
+                ValueError,
+                'Must be empty',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v
+
+    def not_empty(self, v: SizedT, msg: CheckMessage = None) -> SizedT:
+        if len(v) == 0:
+            self._raise(
+                ValueError,
+                'Must not be empty',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
 
-def check_empty(v: SizedT) -> SizedT:
-    if len(v):
-        raise ValueError(v)
-    return v
+        return v
+
+    def unique(self, it: ta.Iterable[T], msg: CheckMessage = None) -> ta.Iterable[T]:
+        dupes = [e for e, c in collections.Counter(it).items() if c > 1]
+        if dupes:
+            self._raise(
+                ValueError,
+                'Must be unique',
+                msg,
+                Checks._ArgsKwargs(it, dupes),
+            )
+
+        return it
+
+    def single(self, obj: ta.Iterable[T], message: CheckMessage = None) -> T:
+        try:
+            [value] = obj
+        except ValueError:
+            self._raise(
+                ValueError,
+                'Must be single',
+                message,
+                Checks._ArgsKwargs(obj),
+                render_fmt='%s',
+            )
+
+        return value
+
+    def opt_single(self, obj: ta.Iterable[T], message: CheckMessage = None) -> ta.Optional[T]:
+        it = iter(obj)
+        try:
+            value = next(it)
+        except StopIteration:
+            return None
+
+        try:
+            next(it)
+        except StopIteration:
+            return value  # noqa
+
+        self._raise(
+            ValueError,
+            'Must be empty or single',
+            message,
+            Checks._ArgsKwargs(obj),
+            render_fmt='%s',
+        )
+
+        raise RuntimeError  # noqa
+
+    #
+
+    def none(self, v: ta.Any, msg: CheckMessage = None) -> None:
+        if v is not None:
+            self._raise(
+                ValueError,
+                'Must be None',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+    def not_none(self, v: ta.Optional[T], msg: CheckMessage = None) -> T:
+        if v is None:
+            self._raise(
+                ValueError,
+                'Must not be None',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v
+
+    #
+
+    def equal(self, v: T, o: ta.Any, msg: CheckMessage = None) -> T:
+        if o != v:
+            self._raise(
+                ValueError,
+                'Must be equal',
+                msg,
+                Checks._ArgsKwargs(v, o),
+                render_fmt='%s != %s',
+            )
+
+        return v
+
+    def is_(self, v: T, o: ta.Any, msg: CheckMessage = None) -> T:
+        if o is not v:
+            self._raise(
+                ValueError,
+                'Must be the same',
+                msg,
+                Checks._ArgsKwargs(v, o),
+                render_fmt='%s is not %s',
+            )
+
+        return v
+
+    def is_not(self, v: T, o: ta.Any, msg: CheckMessage = None) -> T:
+        if o is v:
+            self._raise(
+                ValueError,
+                'Must not be the same',
+                msg,
+                Checks._ArgsKwargs(v, o),
+                render_fmt='%s is %s',
+            )
+
+        return v
+
+    def callable(self, v: T, msg: CheckMessage = None) -> T:  # noqa
+        if not callable(v):
+            self._raise(
+                TypeError,
+                'Must be callable',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v  # type: ignore
+
+    def non_empty_str(self, v: ta.Optional[str], msg: CheckMessage = None) -> str:
+        if not isinstance(v, str) or not v:
+            self._raise(
+                ValueError,
+                'Must be non-empty str',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v
+
+    def replacing(self, expected: ta.Any, old: ta.Any, new: T, msg: CheckMessage = None) -> T:
+        if old != expected:
+            self._raise(
+                ValueError,
+                'Must be replacing',
+                msg,
+                Checks._ArgsKwargs(expected, old, new),
+                render_fmt='%s -> %s -> %s',
+            )
+
+        return new
+
+    def replacing_none(self, old: ta.Any, new: T, msg: CheckMessage = None) -> T:
+        if old is not None:
+            self._raise(
+                ValueError,
+                'Must be replacing None',
+                msg,
+                Checks._ArgsKwargs(old, new),
+                render_fmt='%s -> %s',
+            )
+
+        return new
+
+    #
+
+    def arg(self, v: bool, msg: CheckMessage = None) -> None:
+        if not v:
+            self._raise(
+                RuntimeError,
+                'Argument condition not met',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+    def state(self, v: bool, msg: CheckMessage = None) -> None:
+        if not v:
+            self._raise(
+                RuntimeError,
+                'State condition not met',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
 
 
-def check_not_empty(v: SizedT) -> SizedT:
-    if not len(v):
-        raise ValueError(v)
-    return v
+check = Checks()
 
 
 ########################################
@@ -1324,7 +1680,7 @@ class AwsSigner:
     @staticmethod
     def _host_from_url(url: str) -> str:
         url_parts = urllib.parse.urlsplit(url)
-        host = check_non_empty_str(url_parts.hostname)
+        host = check.non_empty_str(url_parts.hostname)
         default_ports = {
             'http': 80,
             'https': 443,
@@ -1338,7 +1694,7 @@ class AwsSigner:
     def _lower_case_http_map(d: ta.Mapping[str, ta.Sequence[str]]) -> ta.Mapping[str, ta.Sequence[str]]:
         o: ta.Dict[str, ta.List[str]] = {}
         for k, vs in d.items():
-            o.setdefault(k.lower(), []).extend(check_not_isinstance(vs, str))
+            o.setdefault(k.lower(), []).extend(check.not_isinstance(vs, str))
         return o
 
     #
@@ -1371,12 +1727,12 @@ class AwsSigner:
     ])
 
     def _validate_request(self, req: Request) -> None:
-        check_non_empty_str(req.method)
-        check_equal(req.method.upper(), req.method)
+        check.non_empty_str(req.method)
+        check.equal(req.method.upper(), req.method)
         for k, vs in req.headers.items():
-            check_equal(k.strip(), k)
+            check.equal(k.strip(), k)
             for v in vs:
-                check_equal(v.strip(), v)
+                check.equal(v.strip(), v)
 
 
 AwsSigner._EMPTY_SHA256 = AwsSigner._sha256(b'')  # noqa
@@ -1669,7 +2025,7 @@ class DelimitingBuffer:
     ) -> None:
         super().__init__()
 
-        self._delimiters = frozenset(check_isinstance(d, int) for d in delimiters)
+        self._delimiters = frozenset(check.isinstance(d, int) for d in delimiters)
         self._keep_ends = keep_ends
         self._max_size = max_size
 
@@ -1700,7 +2056,7 @@ class DelimitingBuffer:
         return r
 
     def _append_and_reset(self, chunk: bytes) -> bytes:
-        buf = check_not_none(self._buf)
+        buf = check.not_none(self._buf)
         if not buf.tell():
             return chunk
 
@@ -1822,7 +2178,7 @@ class IncrementalWriteBuffer:
     ) -> None:
         super().__init__()
 
-        check_not_empty(data)
+        check.not_empty(data)
         self._len = len(data)
         self._write_size = write_size
 
@@ -1837,11 +2193,11 @@ class IncrementalWriteBuffer:
         return self._len - self._pos
 
     def write(self, fn: ta.Callable[[bytes], int]) -> int:
-        lst = check_not_empty(self._lst)
+        lst = check.not_empty(self._lst)
 
         t = 0
         for i, d in enumerate(lst):  # noqa
-            n = fn(check_not_empty(d))
+            n = fn(check.not_empty(d))
             if not n:
                 break
             t += n
@@ -1867,7 +2223,7 @@ class ExitStacked:
     _exit_stack: ta.Optional[contextlib.ExitStack] = None
 
     def __enter__(self: ExitStackedT) -> ExitStackedT:
-        check_state(self._exit_stack is None)
+        check.state(self._exit_stack is None)
         es = self._exit_stack = contextlib.ExitStack()
         es.__enter__()
         return self
@@ -1882,7 +2238,7 @@ class ExitStacked:
         pass
 
     def _enter_context(self, cm: ta.ContextManager[T]) -> T:
-        es = check_not_none(self._exit_stack)
+        es = check.not_none(self._exit_stack)
         return es.enter_context(cm)
 
 
@@ -2225,10 +2581,10 @@ class ProxyObjMarshaler(ObjMarshaler):
     m: ta.Optional[ObjMarshaler] = None
 
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return check_not_none(self.m).marshal(o, ctx)
+        return check.not_none(self.m).marshal(o, ctx)
 
     def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return check_not_none(self.m).unmarshal(o, ctx)
+        return check.not_none(self.m).unmarshal(o, ctx)
 
 
 @dc.dataclass(frozen=True)
@@ -2387,19 +2743,19 @@ class DatetimeObjMarshaler(ObjMarshaler):
 
 class DecimalObjMarshaler(ObjMarshaler):
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return str(check_isinstance(o, decimal.Decimal))
+        return str(check.isinstance(o, decimal.Decimal))
 
     def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return decimal.Decimal(check_isinstance(v, str))
+        return decimal.Decimal(check.isinstance(v, str))
 
 
 class FractionObjMarshaler(ObjMarshaler):
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        fr = check_isinstance(o, fractions.Fraction)
+        fr = check.isinstance(o, fractions.Fraction)
         return [fr.numerator, fr.denominator]
 
     def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        num, denom = check_isinstance(v, list)
+        num, denom = check.isinstance(v, list)
         return fractions.Fraction(num, denom)
 
 
@@ -2775,8 +3131,8 @@ class AwsLogMessageBuilder:
     ) -> None:
         super().__init__()
 
-        self._log_group_name = check_non_empty_str(log_group_name)
-        self._log_stream_name = check_non_empty_str(log_stream_name)
+        self._log_group_name = check.non_empty_str(log_group_name)
+        self._log_stream_name = check.non_empty_str(log_stream_name)
 
         if url is None:
             url = self.DEFAULT_URL.format(region_name=region_name)
@@ -2850,7 +3206,7 @@ class AwsLogMessageBuilder:
 
         post = AwsLogMessageBuilder.Post(
             url=self._url,
-            headers={k: check_single(v) for k, v in sig_req.headers.items()},
+            headers={k: check.single(v) for k, v in sig_req.headers.items()},
             data=sig_req.payload,
         )
 
@@ -2918,7 +3274,7 @@ def build_config_named_children(
     lst: ta.List[ConfigMapping] = []
     if isinstance(o, ta.Mapping):
         for k, v in o.items():
-            check_isinstance(v, ta.Mapping)
+            check.isinstance(v, ta.Mapping)
             if name_key in v:
                 n = v[name_key]
                 if k != n:
@@ -2928,7 +3284,7 @@ def build_config_named_children(
                 lst.append({name_key: k, **v})
 
     else:
-        check_not_isinstance(o, str)
+        check.not_isinstance(o, str)
         lst.extend(o)
 
     seen = set()
@@ -3010,7 +3366,7 @@ class JournalctlMessageBuilder:
     def feed(self, data: bytes) -> ta.Sequence[JournalctlMessage]:
         ret: ta.List[JournalctlMessage] = []
         for line in self._buf.feed(data):
-            ret.append(self._make_message(check_isinstance(line, bytes)))
+            ret.append(self._make_message(check.isinstance(line, bytes)))
         return ret
 
 
@@ -3948,7 +4304,7 @@ class JournalctlTailerWorker(ThreadWorker):
             stdout=subprocess.PIPE,
         ) as self._proc:
             try:
-                stdout = check_not_none(self._proc.stdout)
+                stdout = check.not_none(self._proc.stdout)
 
                 fd = stdout.fileno()
                 fl = fcntl.fcntl(fd, fcntl.F_GETFL)
@@ -4080,15 +4436,15 @@ class JournalctlToAwsDriver(ExitStacked):
             return None
 
         return AwsSigner.Credentials(
-            access_key_id=check_non_empty_str(self._config.aws_access_key_id),
-            secret_access_key=check_non_empty_str(self._config.aws_secret_access_key),
+            access_key_id=check.non_empty_str(self._config.aws_access_key_id),
+            secret_access_key=check.non_empty_str(self._config.aws_secret_access_key),
         )
 
     @cached_nullary
     def _aws_log_message_builder(self) -> AwsLogMessageBuilder:
         return AwsLogMessageBuilder(
             log_group_name=self._config.aws_log_group_name,
-            log_stream_name=check_non_empty_str(self._config.aws_log_stream_name),
+            log_stream_name=check.non_empty_str(self._config.aws_log_stream_name),
             region_name=self._config.aws_region_name,
             credentials=self._aws_credentials(),
         )