omdev 0.0.0.dev7__py3-none-any.whl

omdev/toml/writer.py

@@ -0,0 +1,104 @@
+import string
+import typing as ta
+
+
+class TomlWriter:
+    def __init__(self, out: ta.TextIO) -> None:
+        super().__init__()
+        self._out = out
+
+        self._indent = 0
+        self._wrote_indent = False
+
+    #
+
+    def _w(self, s: str) -> None:
+        if not self._wrote_indent:
+            self._out.write('    ' * self._indent)
+            self._wrote_indent = True
+        self._out.write(s)
+
+    def _nl(self) -> None:
+        self._out.write('\n')
+        self._wrote_indent = False
+
+    def _needs_quote(self, s: str) -> bool:
+        return (
+            not s or
+            any(c in s for c in '\'"\n') or
+            s[0] not in string.ascii_letters
+        )
+
+    def _maybe_quote(self, s: str) -> str:
+        if self._needs_quote(s):
+            return repr(s)
+        else:
+            return s
+
+    #
+
+    def write_root(self, obj: ta.Mapping) -> None:
+        for i, (k, v) in enumerate(obj.items()):
+            if i:
+                self._nl()
+            self._w('[')
+            self._w(self._maybe_quote(k))
+            self._w(']')
+            self._nl()
+            self.write_table_contents(v)
+
+    def write_table_contents(self, obj: ta.Mapping) -> None:
+        for k, v in obj.items():
+            self.write_key(k)
+            self._w(' = ')
+            self.write_value(v)
+            self._nl()
+
+    def write_array(self, obj: ta.Sequence) -> None:
+        self._w('[')
+        self._nl()
+        self._indent += 1
+        for e in obj:
+            self.write_value(e)
+            self._w(',')
+            self._nl()
+        self._indent -= 1
+        self._w(']')
+
+    def write_inline_table(self, obj: ta.Mapping) -> None:
+        self._w('{')
+        for i, (k, v) in enumerate(obj.items()):
+            if i:
+                self._w(', ')
+            self.write_key(k)
+            self._w(' = ')
+            self.write_value(v)
+        self._w('}')
+
+    def write_inline_array(self, obj: ta.Sequence) -> None:
+        self._w('[')
+        for i, e in enumerate(obj):
+            if i:
+                self._w(', ')
+            self.write_value(e)
+        self._w(']')
+
+    def write_key(self, obj: ta.Any) -> None:
+        if isinstance(obj, str):
+            self._w(self._maybe_quote(obj.replace('_', '-')))
+        elif isinstance(obj, int):
+            self._w(repr(str(obj)))
+        else:
+            raise TypeError(obj)
+
+    def write_value(self, obj: ta.Any) -> None:
+        if isinstance(obj, bool):
+            self._w(str(obj).lower())
+        elif isinstance(obj, (str, int, float)):
+            self._w(repr(obj))
+        elif isinstance(obj, ta.Mapping):
+            self.write_inline_table(obj)
+        elif isinstance(obj, ta.Sequence):
+            self.write_array(obj)
+        else:
+            raise TypeError(obj)

omdev/tools/dockertools.py

@@ -0,0 +1,81 @@
+import os
+import shutil
+import subprocess
+
+from omlish import argparse as ap
+from omlish import check
+from omlish import lang
+from omlish import logs
+
+
+@lang.cached_function
+def docker_exe() -> str:
+    return check.not_none(shutil.which('docker'))
+
+
+@lang.cached_function
+def get_local_platform() -> str:
+    return subprocess.check_output([
+        docker_exe(),
+        'system',
+        'info',
+        '--format',
+        '{{.OSType}}/{{.Architecture}}',
+    ]).decode().strip()
+
+
+class Cli(ap.Cli):
+    @ap.command(
+        ap.arg('args', nargs='*'),
+    )
+    def ns1(self) -> None:
+        """
+        - https://gist.github.com/BretFisher/5e1a0c7bcca4c735e716abf62afad389
+        - https://github.com/justincormack/nsenter1/blob/8d3ba504b2c14d73c70cf34f1ec6943c093f1b02/nsenter1.c
+
+        alt:
+         - nc -U ~/Library/Containers/com.docker.docker/Data/debug-shell.sock
+        """
+        os.execl(
+            exe := docker_exe(),
+            exe,
+            'run',
+            '--platform', get_local_platform(),
+            '--privileged',
+            '--pid=host',
+            '-it', 'debian',
+            'nsenter',
+            '-t', '1',
+            '-m',  # mount
+            '-u',  # uts
+            '-i',  # ipc
+            '-n',  # net
+            '-p',  # pid
+            '-C',  # cgroup
+            # '-U',  # user
+            '-T',  # time
+            *self.args.args,
+        )
+
+    @ap.command(
+        ap.arg('--amd64', action='store_true'),
+    )
+    def enable_ptrace(self) -> None:
+        """
+        - https://github.com/docker/for-mac/issues/5191
+        - https://forums.docker.com/t/sys-ptrace-capability-for-linux-amd64/138482/4
+        """
+        os.execl(
+            exe := docker_exe(),
+            exe,
+            'run',
+            *(('--platform', 'linux/x86_64') if self.args.amd64 else ()),
+            '--privileged',
+            '-it', 'debian',
+            'sh', '-c', 'echo 0 > /proc/sys/kernel/yama/ptrace_scope',
+        )
+
+
+if __name__ == '__main__':
+    logs.configure_standard_logging('INFO')
+    Cli()()

omdev/tools/sqlrepl.py

@@ -0,0 +1,193 @@
+import dataclasses as dc
+import os.path
+import shutil
+import sys
+import typing as ta
+import urllib.parse
+import warnings
+
+import yaml
+
+from omlish import argparse as ap
+from omlish import check
+from omlish import lang
+from omlish import logs
+
+
+@dc.dataclass(frozen=True)
+class ServerSpec:
+    host: str
+    port: int | None = None
+    username: str | None = None
+    password: str | None = None
+    db: str | None = None
+
+    @classmethod
+    def from_url(cls, url: str) -> 'ServerSpec':
+        parsed = urllib.parse.urlparse(url)
+        if not parsed.hostname:
+            raise NameError(parsed.hostname)
+        if parsed.path:
+            if not parsed.path.startswith('/'):
+                raise NameError(parsed.path)
+            db = parsed.path[1:]
+        else:
+            db = None
+        return ServerSpec(
+            host=parsed.hostname,
+            port=parsed.port or None,
+            username=parsed.username or None,
+            password=parsed.password or None,
+            db=db,
+        )
+
+
+def spec_from_mysql_docker_compose(svc: ta.Mapping[str, ta.Any]) -> ServerSpec:
+    env = svc['environment']
+    return ServerSpec(
+        host='localhost',
+        port=int(svc['ports'][0].split(':')[0]),
+        username=env.get('MYSQL_USER') or None,
+        password=env.get('MYSQL_PASSWORD') or None,
+    )
+
+
+def spec_from_postgres_docker_compose(svc: ta.Mapping[str, ta.Any]) -> ServerSpec:
+    env = svc['environment']
+    return ServerSpec(
+        host='localhost',
+        port=int(svc['ports'][0].split(':')[0]),
+        username=env.get('POSTGRES_USER') or None,
+        password=env.get('POSTGRES_PASSWORD') or None,
+    )
+
+
+def spec_from_cfg(cfg: ta.Mapping[str, ta.Any], prefix: str) -> ServerSpec:
+    return ServerSpec(
+        host=cfg[prefix + '_host'],
+        port=cfg.get(prefix + '_port'),
+        username=cfg.get(prefix + '_user'),
+        password=cfg.get(prefix + '_pass'),
+    )
+
+
+@lang.cached_function
+def _maybe_warn_pgcli_keyring() -> None:
+    import pgcli.config
+
+    c = pgcli.config.get_config()
+    if c['main'].as_bool('keyring'):
+        warnings.warn(
+            'pgcli keyring is not disabled, it will try to store credentials. '
+            'set `keyring = False` in ~/.config/pgcli/config',
+        )
+
+
+def _dbcli_or_fallback_exe(dbcli_mod: str | None, default_exe: str) -> tuple[ta.Sequence[str], bool]:
+    if dbcli_mod is not None:
+        main_mod = dbcli_mod + '.main'
+        try:
+            __import__(main_mod)
+        except ImportError:
+            pass
+        else:
+            if dbcli_mod == 'pgcli':
+                _maybe_warn_pgcli_keyring()
+            return [sys.executable, '-m', main_mod], True
+    return [check.not_none(shutil.which(default_exe))], False
+
+
+def exec_mysql_cli(
+        spec: ServerSpec,
+        *extra_args: str,
+        exe: ta.Iterable[str] | None = None,
+        no_dbcli: bool = False,
+) -> ta.NoReturn:
+    if exe is not None:
+        args, is_dbcli = list(exe), False
+    else:
+        argsx, is_dbcli = _dbcli_or_fallback_exe(
+            'mycli' if not no_dbcli else None,
+            'mysql',
+        )
+        args = list(argsx)
+    if spec.username:
+        args.extend(['--user', spec.username])
+    if spec.password:
+        os.environ['MYSQL_PWD'] = spec.password
+    args.extend(['--host', spec.host])
+    if not is_dbcli:
+        args.append('--protocol=TCP')
+    if spec.port:
+        args.extend(['--port', str(spec.port)])
+    if spec.db:
+        args.append(spec.db)
+    args.extend(extra_args)
+    os.execvp(args[0], args)
+
+
+def exec_postgres_cli(
+        spec: ServerSpec,
+        *extra_args: str,
+        exe: ta.Iterable[str] | None = None,
+        no_dbcli: bool = False,
+) -> ta.NoReturn:
+    if exe is not None:
+        args, is_dbcli = list(exe), False
+    else:
+        argsx, is_dbcli = _dbcli_or_fallback_exe(
+            'pgcli' if not no_dbcli else None,
+            'psql',
+        )
+        args = list(argsx)
+    if spec.username:
+        args.extend(['--username', spec.username])
+    if spec.password:
+        os.environ['PGPASSWORD'] = spec.password
+    if spec.host:
+        args.extend(['--host', spec.host])
+    if spec.port:
+        args.extend(['--port', str(spec.port)])
+    if spec.db:
+        args.append(spec.db)
+    args.extend(extra_args)
+    os.execvp(args[0], args)
+
+
+class Cli(ap.Cli):
+    @ap.command(
+        ap.arg('--no-dbcli', action='store_true'),
+        ap.arg('dialect'),
+        ap.arg('target'),
+        ap.arg('args', nargs='*'),
+    )
+    def repl(self) -> None:
+        l, _, r = (target := self.args.target).partition(':')
+        _, lf = os.path.dirname(l), os.path.basename(l)
+        if not lf.endswith('.yml'):
+            raise Exception(f'unhandled target: {target=}')
+        with open(l) as f:
+            cfg = yaml.safe_load(f.read())
+        dialect = self.args.dialect
+        if lf == 'compose.yml':
+            svc = cfg['services'][r]
+            if dialect == 'mysql':
+                spec = spec_from_mysql_docker_compose(svc)
+            elif dialect == 'postgres':
+                spec = spec_from_postgres_docker_compose(svc)
+            else:
+                raise Exception(f'unhandled dialect: {dialect=}')
+        else:
+            spec = spec_from_cfg(cfg, r)
+
+        if dialect == 'mysql':
+            exec_mysql_cli(spec, *self.args.args, no_dbcli=self.args.no_dbcli)
+        elif dialect == 'postgres':
+            exec_postgres_cli(spec, *self.args.args, no_dbcli=self.args.no_dbcli)
+        else:
+            raise Exception(f'unhandled dialect: {dialect=}')
+
+
+if __name__ == '__main__':
+    logs.configure_standard_logging('INFO')
+    Cli()()

omdev/versioning/__init__.py

@@ -0,0 +1 @@
+# @omlish-lite