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

ominfra/clouds/aws/auth.py

@@ -17,9 +17,7 @@ import hmac
 import typing as ta
 import urllib.parse
 
-from omlish.lite.check import check_equal
-from omlish.lite.check import check_non_empty_str
-from omlish.lite.check import check_not_isinstance
+from omlish.lite.check import check
 
 
 ##
@@ -60,7 +58,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,
@@ -74,7 +72,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
 
     #
@@ -107,12 +105,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

ominfra/clouds/aws/cli.py

@@ -1,4 +1,4 @@
-from omlish import argparse as ap
+from omlish.argparse import all as ap
 from omlish.formats import json
 
 from . import metadata

ominfra/clouds/aws/journald2aws/driver.py

@@ -38,7 +38,7 @@ import time
 import typing as ta
 
 from omlish.lite.cached import cached_nullary
-from omlish.lite.check import check_non_empty_str
+from omlish.lite.check import check
 from omlish.lite.contextmanagers import ExitStacked
 from omlish.lite.logs import log
 from omlish.lite.pidfile import Pidfile
@@ -126,15 +126,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(),
         )

ominfra/clouds/aws/logs.py

@@ -19,8 +19,7 @@ import dataclasses as dc
 import json
 import typing as ta
 
-from omlish.lite.check import check_non_empty_str
-from omlish.lite.check import check_single
+from omlish.lite.check import check
 
 from .auth import AwsSigner
 from .auth import V4AwsSigner
@@ -97,8 +96,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)
@@ -172,7 +171,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,
         )
 

ominfra/clouds/gcp/auth.py

@@ -3,7 +3,7 @@ import time
 import typing as ta
 
 from omlish import check
-from omlish import http
+from omlish.http import all as http
 from omlish.http import jwt
 
 

ominfra/configs.py

@@ -5,8 +5,7 @@ import os.path
 import typing as ta
 
 from omdev.toml.parser import toml_loads
-from omlish.lite.check import check_isinstance
-from omlish.lite.check import check_not_isinstance
+from omlish.lite.check import check
 from omlish.lite.marshal import unmarshal_obj
 
 
@@ -72,7 +71,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:
@@ -82,7 +81,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()

ominfra/journald/messages.py

@@ -4,8 +4,8 @@ import dataclasses as dc
 import json
 import typing as ta
 
-from omlish.lite.check import check_isinstance
-from omlish.lite.io import DelimitingBuffer
+from omlish.io.buffers import DelimitingBuffer
+from omlish.lite.check import check
 from omlish.lite.logs import log
 
 
@@ -74,5 +74,5 @@ 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

ominfra/journald/tailer.py

@@ -408,7 +408,7 @@ import time
 import typing as ta
 
 from omlish.lite.cached import cached_nullary
-from omlish.lite.check import check_not_none
+from omlish.lite.check import check
 from omlish.lite.logs import log
 from omlish.lite.subprocesses import subprocess_close
 from omlish.lite.subprocesses import subprocess_shell_wrap_exec
@@ -499,7 +499,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)

ominfra/manage/commands/base.py

@@ -5,7 +5,7 @@ import logging
 import traceback
 import typing as ta
 
-from omlish.lite.check import check_isinstance
+from omlish.lite.check import check
 from omlish.lite.strings import snake_case
 
 
@@ -24,7 +24,7 @@ class Command(abc.ABC, ta.Generic[CommandOutputT]):
 
     @ta.final
     async def execute(self, executor: 'CommandExecutor') -> CommandOutputT:
-        return check_isinstance(await executor.execute(self), self.Output)  # type: ignore[return-value]
+        return check.isinstance(await executor.execute(self), self.Output)  # type: ignore[return-value]
 
 
 ##

ominfra/manage/commands/interp.py

@@ -4,7 +4,7 @@ import dataclasses as dc
 from omdev.interp.resolvers import DEFAULT_INTERP_RESOLVER
 from omdev.interp.types import InterpOpts
 from omdev.interp.types import InterpSpecifier
-from omlish.lite.check import check_not_none
+from omlish.lite.check import check
 
 from ..commands.base import Command
 from ..commands.base import CommandExecutor
@@ -30,8 +30,8 @@ class InterpCommand(Command['InterpCommand.Output']):
 
 class InterpCommandExecutor(CommandExecutor[InterpCommand, InterpCommand.Output]):
     async def execute(self, cmd: InterpCommand) -> InterpCommand.Output:
-        i = InterpSpecifier.parse(check_not_none(cmd.spec))
-        o = check_not_none(await DEFAULT_INTERP_RESOLVER.resolve(i, install=cmd.install))
+        i = InterpSpecifier.parse(check.not_none(cmd.spec))
+        o = check.not_none(await DEFAULT_INTERP_RESOLVER.resolve(i, install=cmd.install))
         return InterpCommand.Output(
             exe=o.exe,
             version=str(o.version.version),

ominfra/manage/commands/subprocess.py

@@ -8,8 +8,7 @@ import typing as ta
 
 from omlish.lite.asyncio.subprocesses import asyncio_subprocess_communicate
 from omlish.lite.asyncio.subprocesses import asyncio_subprocess_popen
-from omlish.lite.check import check_not_isinstance
-from omlish.lite.check import check_not_none
+from omlish.lite.check import check
 from omlish.lite.subprocesses import SUBPROCESS_CHANNEL_OPTION_VALUES
 from omlish.lite.subprocesses import SubprocessChannelOption
 from omlish.lite.subprocesses import subprocess_maybe_shell_wrap_exec
@@ -36,7 +35,7 @@ class SubprocessCommand(Command['SubprocessCommand.Output']):
     timeout: ta.Optional[float] = None
 
     def __post_init__(self) -> None:
-        check_not_isinstance(self.cmd, str)
+        check.not_isinstance(self.cmd, str)
 
     @dc.dataclass(frozen=True)
     class Output(Command.Output):
@@ -77,7 +76,7 @@ class SubprocessCommandExecutor(CommandExecutor[SubprocessCommand, SubprocessCom
             end_time = time.time()
 
         return SubprocessCommand.Output(
-            rc=check_not_none(proc.returncode),
+            rc=check.not_none(proc.returncode),
             pid=proc.pid,
 
             elapsed_s=end_time - start_time,

ominfra/manage/deploy/paths.py

@@ -36,10 +36,7 @@ import dataclasses as dc
 import os.path
 import typing as ta
 
-from omlish.lite.check import check_equal
-from omlish.lite.check import check_non_empty
-from omlish.lite.check import check_non_empty_str
-from omlish.lite.check import check_not_in
+from omlish.lite.check import check
 
 
 DeployPathKind = ta.Literal['dir', 'file']  # ta.TypeAlias
@@ -74,7 +71,7 @@ class DeployPathDir(DeployPathPart, abc.ABC):
     @classmethod
     def parse(cls, s: str) -> 'DeployPathDir':
         if DEPLOY_PATH_SPEC_PLACEHOLDER in s:
-            check_equal(s, DEPLOY_PATH_SPEC_PLACEHOLDER)
+            check.equal(s, DEPLOY_PATH_SPEC_PLACEHOLDER)
             return SpecDeployPathDir()
         else:
             return ConstDeployPathDir(s)
@@ -88,7 +85,7 @@ class DeployPathFile(DeployPathPart, abc.ABC):
     @classmethod
     def parse(cls, s: str) -> 'DeployPathFile':
         if DEPLOY_PATH_SPEC_PLACEHOLDER in s:
-            check_equal(s[0], DEPLOY_PATH_SPEC_PLACEHOLDER)
+            check.equal(s[0], DEPLOY_PATH_SPEC_PLACEHOLDER)
             return SpecDeployPathFile(s[1:])
         else:
             return ConstDeployPathFile(s)
@@ -102,9 +99,9 @@ class ConstDeployPathPart(DeployPathPart, abc.ABC):
     name: str
 
     def __post_init__(self) -> None:
-        check_non_empty_str(self.name)
-        check_not_in('/', self.name)
-        check_not_in(DEPLOY_PATH_SPEC_PLACEHOLDER, self.name)
+        check.non_empty_str(self.name)
+        check.not_in('/', self.name)
+        check.not_in(DEPLOY_PATH_SPEC_PLACEHOLDER, self.name)
 
     def render(self) -> str:
         return self.name
@@ -135,9 +132,9 @@ class SpecDeployPathFile(SpecDeployPathPart, DeployPathFile):
     suffix: str
 
     def __post_init__(self) -> None:
-        check_non_empty_str(self.suffix)
-        check_not_in('/', self.suffix)
-        check_not_in(DEPLOY_PATH_SPEC_PLACEHOLDER, self.suffix)
+        check.non_empty_str(self.suffix)
+        check.not_in('/', self.suffix)
+        check.not_in(DEPLOY_PATH_SPEC_PLACEHOLDER, self.suffix)
 
     def render(self) -> str:
         return DEPLOY_PATH_SPEC_PLACEHOLDER + self.suffix
@@ -151,9 +148,9 @@ class DeployPath:
     parts: ta.Sequence[DeployPathPart]
 
     def __post_init__(self) -> None:
-        check_non_empty(self.parts)
+        check.not_empty(self.parts)
         for p in self.parts[:-1]:
-            check_equal(p.kind, 'dir')
+            check.equal(p.kind, 'dir')
 
     @property
     def kind(self) -> ta.Literal['file', 'dir']:
@@ -173,7 +170,7 @@ class DeployPath:
             s = s[:-1]
         else:
             tail_parse = DeployPathFile.parse
-        ps = check_non_empty_str(s).split('/')
+        ps = check.non_empty_str(s).split('/')
         return cls([
             *([DeployPathDir.parse(p) for p in ps[:-1]] if len(ps) > 1 else []),
             tail_parse(ps[-1]),

ominfra/manage/main.py

@@ -10,6 +10,9 @@ import contextlib
 import json
 import typing as ta
 
+from omlish.argparse.cli import ArgparseCli
+from omlish.argparse.cli import argparse_arg
+from omlish.argparse.cli import argparse_command
 from omlish.lite.logs import log  # noqa
 from omlish.lite.marshal import ObjMarshalerManager
 from omlish.lite.marshal import ObjMarshalOptions
@@ -26,108 +29,102 @@ from .remote.connection import RemoteExecutionConnector
 from .remote.spawning import RemoteSpawning
 
 
-##
+class MainCli(ArgparseCli):
+    @argparse_command(
+        argparse_arg('--payload-file'),
 
+        argparse_arg('-s', '--shell'),
+        argparse_arg('-q', '--shell-quote', action='store_true'),
+        argparse_arg('--python', default='python3'),
 
-async def _async_main(args: ta.Any) -> None:
-    bs = MainBootstrap(
-        main_config=MainConfig(
-            log_level='DEBUG' if args.debug else 'INFO',
+        argparse_arg('--pycharm-debug-port', type=int),
+        argparse_arg('--pycharm-debug-host'),
+        argparse_arg('--pycharm-debug-version'),
 
-            debug=bool(args.debug),
-        ),
+        argparse_arg('--remote-timebomb-delay-s', type=float),
 
-        remote_config=RemoteConfig(
-            payload_file=args._payload_file,  # noqa
+        argparse_arg('--debug', action='store_true'),
 
-            pycharm_remote_debug=PycharmRemoteDebug(
-                port=args.pycharm_debug_port,
-                **(dict(host=args.pycharm_debug_host) if args.pycharm_debug_host is not None else {}),
-                install_version=args.pycharm_debug_version,
-            ) if args.pycharm_debug_port is not None else None,
+        argparse_arg('--local', action='store_true'),
 
-            timebomb_delay_s=args.remote_timebomb_delay_s,
-        ),
+        argparse_arg('command', nargs='+'),
     )
+    def run(self) -> None:
+        asyncio.run(self._async_run())
 
-    #
+    async def _async_run(self) -> None:
+        bs = MainBootstrap(
+            main_config=MainConfig(
+                log_level='DEBUG' if self.args.debug else 'INFO',
 
-    injector = main_bootstrap(
-        bs,
-    )
-
-    #
-
-    msh = injector[ObjMarshalerManager]
+                debug=bool(self.args.debug),
+            ),
 
-    cmds: ta.List[Command] = []
-    cmd: Command
-    for c in args.command:
-        if not c.startswith('{'):
-            c = json.dumps({c: {}})
-        cmd = msh.unmarshal_obj(json.loads(c), Command)
-        cmds.append(cmd)
+            remote_config=RemoteConfig(
+                payload_file=self.args.payload_file,  # noqa
 
-    #
+                pycharm_remote_debug=PycharmRemoteDebug(
+                    port=self.args.pycharm_debug_port,
+                    **(dict(host=self.args.pycharm_debug_host) if self.args.pycharm_debug_host is not None else {}),
+                    install_version=self.args.pycharm_debug_version,
+                ) if self.args.pycharm_debug_port is not None else None,
 
-    async with contextlib.AsyncExitStack() as es:
-        ce: CommandExecutor
+                timebomb_delay_s=self.args.remote_timebomb_delay_s,
+            ),
+        )
 
-        if args.local:
-            ce = injector[LocalCommandExecutor]
+        #
 
-        else:
-            tgt = RemoteSpawning.Target(
-                shell=args.shell,
-                shell_quote=args.shell_quote,
-                python=args.python,
-            )
+        injector = main_bootstrap(
+            bs,
+        )
 
-            ce = await es.enter_async_context(injector[RemoteExecutionConnector].connect(tgt, bs))  # noqa
+        #
 
-        async def run_command(cmd: Command) -> None:
-            res = await ce.try_execute(
-                cmd,
-                log=log,
-                omit_exc_object=True,
-            )
+        msh = injector[ObjMarshalerManager]
 
-            print(msh.marshal_obj(res, opts=ObjMarshalOptions(raw_bytes=True)))
+        cmds: ta.List[Command] = []
+        cmd: Command
+        for c in self.args.command:
+            if not c.startswith('{'):
+                c = json.dumps({c: {}})
+            cmd = msh.unmarshal_obj(json.loads(c), Command)
+            cmds.append(cmd)
 
-        await asyncio.gather(*[
-            run_command(cmd)
-            for cmd in cmds
-        ])
+        #
 
+        async with contextlib.AsyncExitStack() as es:
+            ce: CommandExecutor
 
-def _main() -> None:
-    import argparse
-
-    parser = argparse.ArgumentParser()
+            if self.args.local:
+                ce = injector[LocalCommandExecutor]
 
-    parser.add_argument('--_payload-file')
+            else:
+                tgt = RemoteSpawning.Target(
+                    shell=self.args.shell,
+                    shell_quote=self.args.shell_quote,
+                    python=self.args.python,
+                )
 
-    parser.add_argument('-s', '--shell')
-    parser.add_argument('-q', '--shell-quote', action='store_true')
-    parser.add_argument('--python', default='python3')
+                ce = await es.enter_async_context(injector[RemoteExecutionConnector].connect(tgt, bs))  # noqa
 
-    parser.add_argument('--pycharm-debug-port', type=int)
-    parser.add_argument('--pycharm-debug-host')
-    parser.add_argument('--pycharm-debug-version')
+            async def run_command(cmd: Command) -> None:
+                res = await ce.try_execute(
+                    cmd,
+                    log=log,
+                    omit_exc_object=True,
+                )
 
-    parser.add_argument('--remote-timebomb-delay-s', type=float)
+                print(msh.marshal_obj(res, opts=ObjMarshalOptions(raw_bytes=True)))
 
-    parser.add_argument('--debug', action='store_true')
+            await asyncio.gather(*[
+                run_command(cmd)
+                for cmd in cmds
+            ])
 
-    parser.add_argument('--local', action='store_true')
 
-    parser.add_argument('command', nargs='+')
-
-    args = parser.parse_args()
-
-    #
-
-    asyncio.run(_async_main(args))
+def _main() -> None:
+    MainCli().call_and_exit()
 
 
 if __name__ == '__main__':

ominfra/manage/remote/_main.py

@@ -11,8 +11,7 @@ import typing as ta
 from omlish.lite.asyncio.asyncio import asyncio_open_stream_reader
 from omlish.lite.asyncio.asyncio import asyncio_open_stream_writer
 from omlish.lite.cached import cached_nullary
-from omlish.lite.check import check_none
-from omlish.lite.check import check_not_none
+from omlish.lite.check import check
 from omlish.lite.deathsig import set_process_deathsig
 from omlish.lite.inject import Injector
 from omlish.lite.logs import log
@@ -64,11 +63,11 @@ class _RemoteExecutionMain:
 
     @property
     def _bootstrap(self) -> MainBootstrap:
-        return check_not_none(self.__bootstrap)
+        return check.not_none(self.__bootstrap)
 
     @property
     def _injector(self) -> Injector:
-        return check_not_none(self.__injector)
+        return check.not_none(self.__injector)
 
     #
 
@@ -112,12 +111,12 @@ class _RemoteExecutionMain:
     #
 
     async def _setup(self) -> None:
-        check_none(self.__bootstrap)
-        check_none(self.__injector)
+        check.none(self.__bootstrap)
+        check.none(self.__injector)
 
         # Bootstrap
 
-        self.__bootstrap = check_not_none(await self._chan.recv_obj(MainBootstrap))
+        self.__bootstrap = check.not_none(await self._chan.recv_obj(MainBootstrap))
 
         if (prd := self._bootstrap.remote_config.pycharm_remote_debug) is not None:
             pycharm_debug_connect(prd)

ominfra/manage/remote/execution.py

@@ -6,10 +6,7 @@ import itertools
 import logging
 import typing as ta
 
-from omlish.lite.check import check_isinstance
-from omlish.lite.check import check_none
-from omlish.lite.check import check_not_none
-from omlish.lite.check import check_state
+from omlish.lite.check import check
 from omlish.lite.logs import log
 
 from ..commands.base import Command
@@ -133,7 +130,7 @@ class _RemoteCommandHandler:
             ], return_when=asyncio.FIRST_COMPLETED)
 
             if recv_task in done:
-                msg: ta.Optional[_RemoteProtocol.Message] = check_isinstance(
+                msg: ta.Optional[_RemoteProtocol.Message] = check.isinstance(
                     recv_task.result(),
                     (_RemoteProtocol.Message, type(None)),
                 )
@@ -202,8 +199,8 @@ class RemoteCommandExecutor(CommandExecutor):
     #
 
     async def start(self) -> None:
-        check_none(self._loop_task)
-        check_state(not self._stop.is_set())
+        check.none(self._loop_task)
+        check.state(not self._stop.is_set())
         self._loop_task = asyncio.create_task(self._loop())
 
     async def aclose(self) -> None:
@@ -239,12 +236,12 @@ class RemoteCommandExecutor(CommandExecutor):
             ], return_when=asyncio.FIRST_COMPLETED)
 
             if queue_task in done:
-                req = check_isinstance(queue_task.result(), RemoteCommandExecutor._Request)
+                req = check.isinstance(queue_task.result(), RemoteCommandExecutor._Request)
                 queue_task = None
                 await self._handle_request(req)
 
             if recv_task in done:
-                msg: ta.Optional[_RemoteProtocol.Message] = check_isinstance(
+                msg: ta.Optional[_RemoteProtocol.Message] = check.isinstance(
                     recv_task.result(),
                     (_RemoteProtocol.Message, type(None)),
                 )
@@ -312,7 +309,7 @@ class RemoteCommandExecutor(CommandExecutor):
         if (e := r.exception) is not None:
             raise RemoteCommandError(e)
         else:
-            return check_not_none(r.output)
+            return check.not_none(r.output)
 
     # @ta.override
     async def try_execute(

ominfra/manage/remote/spawning.py

@@ -8,7 +8,7 @@ import subprocess
 import typing as ta
 
 from omlish.lite.asyncio.subprocesses import asyncio_subprocess_popen
-from omlish.lite.check import check_not_none
+from omlish.lite.check import check
 from omlish.lite.subprocesses import SUBPROCESS_CHANNEL_OPTION_VALUES
 from omlish.lite.subprocesses import SubprocessChannelOption
 from omlish.lite.subprocesses import subprocess_maybe_shell_wrap_exec
@@ -97,8 +97,8 @@ class SubprocessRemoteSpawning(RemoteSpawning):
                 ),
                 timeout=timeout,
         ) as proc:
-            stdin = check_not_none(proc.stdin)
-            stdout = check_not_none(proc.stdout)
+            stdin = check.not_none(proc.stdin)
+            stdout = check.not_none(proc.stdout)
 
             try:
                 yield RemoteSpawning.Spawned(