omdev 0.0.0.dev500__py3-none-any.whl → 0.0.0.dev506__py3-none-any.whl

omdev/scripts/pyproject.py

@@ -101,7 +101,7 @@ def __omlish_amalg__():  # noqa
             dict(path='../../omlish/lite/objects.py', sha1='9566bbf3530fd71fcc56321485216b592fae21e9'),
             dict(path='../../omlish/lite/reflect.py', sha1='c4fec44bf144e9d93293c996af06f6c65fc5e63d'),
             dict(path='../../omlish/lite/strings.py', sha1='89831ecbc34ad80e118a865eceb390ed399dc4d6'),
-            dict(path='../../omlish/lite/typing.py', sha1='c501ff8f9ed08202e8016eaa098526d4deede834'),
+            dict(path='../../omlish/lite/typing.py', sha1='048bb5fb8ecad5be101516f8f3b7996707f5bc42'),
             dict(path='../../omlish/logs/levels.py', sha1='91405563d082a5eba874da82aac89d83ce7b6152'),
             dict(path='../../omlish/logs/std/filters.py', sha1='f36aab646d84d31e295b33aaaaa6f8b67ff38b3d'),
             dict(path='../../omlish/logs/std/proxy.py', sha1='3e7301a2aa351127f9c85f61b2f85dcc3f15aafb'),
@@ -109,9 +109,10 @@ def __omlish_amalg__():  # noqa
             dict(path='../cexts/magic.py', sha1='4e5ce6732454f75c9dd27352959708d8fa7b1666'),
             dict(path='../magic/find.py', sha1='436228a9cf1d8bab6b9234d09f72913b0960382f'),
             dict(path='../packaging/specifiers.py', sha1='a56ab4e8c9b174adb523921f6280ac41e0fce749'),
+            dict(path='versions.py', sha1='99aa1788f4eccb1901f21f2265862716d7580192'),
             dict(path='../../omlish/argparse/cli.py', sha1='f4dc3cd353d14386b5da0306768700e396afd2b3'),
             dict(path='../../omlish/lite/marshal.py', sha1='96348f5f2a26dc27d842d33cc3927e9da163436b'),
-            dict(path='../../omlish/lite/maybes.py', sha1='bdf5136654ccd14b6a072588cad228925bdfbabd'),
+            dict(path='../../omlish/lite/maybes.py', sha1='04d2fcbea17028a5e6b8e7a7fb742375495ed233'),
             dict(path='../../omlish/lite/runtime.py', sha1='2e752a27ae2bf89b1bb79b4a2da522a3ec360c70'),
             dict(path='../../omlish/lite/timeouts.py', sha1='a0f673033a6943f242e35848d78a41892b9c62a1'),
             dict(path='../../omlish/logs/infos.py', sha1='4dd104bd468a8c438601dd0bbda619b47d2f1620'),
@@ -154,9 +155,9 @@ def __omlish_amalg__():  # noqa
             dict(path='../interp/inject.py', sha1='b039abbadf0b096d2724182af2e0ebda2a230852'),
             dict(path='../interp/default.py', sha1='a799969a0d3f4b57538587b13ceb08f6334ebc16'),
             dict(path='../interp/venvs.py', sha1='9ba8f2c3131d7d519d5cf36ca69b75f9c6fe2b27'),
-            dict(path='configs.py', sha1='7b1c1ed034ecb728d67ff15e3bb2b21a218773c9'),
+            dict(path='configs.py', sha1='28d20c0288eef4a5c61dd9b95071b7b15958b575'),
             dict(path='venvs.py', sha1='9f1935171017aeb802da56e14d7f41d632a7aa25'),
-            dict(path='cli.py', sha1='77efd5e792baa941a79adef6b363751dbd6a0d3e'),
+            dict(path='cli.py', sha1='ecf31ccef6b0e1d1505b46d24faf076b6be32760'),
         ],
     )
 
@@ -3292,6 +3293,21 @@ class CachedFunc0(ta.Generic[T]):
         return value
 
 
+@dc.dataclass(frozen=True)
+class AsyncCachedFunc0(ta.Generic[T]):
+    fn: ta.Callable[[], ta.Awaitable[T]]
+
+    async def __call__(self) -> T:
+        try:
+            return object.__getattribute__(self, '_value')
+        except AttributeError:
+            pass
+
+        value = await self.fn()
+        object.__setattr__(self, '_value', value)
+        return value
+
+
 ##
 
 
@@ -4289,6 +4305,44 @@ class SpecifierSet(BaseSpecifier):
             return iter(filtered)
 
 
+########################################
+# ../versions.py
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class VersionsFile:
+    name: ta.Optional[str] = '.versions'
+
+    @staticmethod
+    def parse(s: str) -> ta.Mapping[str, str]:
+        return {
+            k: v
+            for l in s.splitlines()
+            if (sl := l.split('#')[0].strip())
+            for k, _, v in (sl.partition('='),)
+        }
+
+    @cached_nullary
+    def contents(self) -> ta.Mapping[str, str]:
+        if not self.name or not os.path.exists(self.name):
+            return {}
+        with open(self.name) as f:
+            s = f.read()
+        return self.parse(s)
+
+    @staticmethod
+    def get_pythons(d: ta.Mapping[str, str]) -> ta.Mapping[str, str]:
+        pfx = 'PYTHON_'
+        return {k[len(pfx):].lower(): v for k, v in d.items() if k.startswith(pfx)}
+
+    @cached_nullary
+    def pythons(self) -> ta.Mapping[str, str]:
+        return self.get_pythons(self.contents())
+
+
 ########################################
 # ../../../omlish/argparse/cli.py
 """
@@ -5466,6 +5520,13 @@ class Maybe(ta.Generic[T]):
         else:
             return other
 
+    @ta.final
+    def or_none(self) -> ta.Optional[T]:
+        if self.present:
+            return self.must()
+        else:
+            return None
+
     @ta.final
     def or_else_get(self, supplier: ta.Callable[[], ta.Union[T, U]]) -> ta.Union[T, U]:
         if self.present:
@@ -12355,7 +12416,7 @@ class PyprojectConfig:
     venvs: ta.Mapping[str, VenvConfig] = dc.field(default_factory=dict)
 
     venvs_dir: str = '.venvs'
-    versions_file: ta.Optional[str] = '.versions'
+    # versions_file: ta.Optional[str] = '.versions'  # FIXME:
 
 
 class PyprojectConfigPreparer:
@@ -12518,40 +12579,6 @@ class Venv:
 ##
 
 
-@dc.dataclass(frozen=True)
-class VersionsFile:
-    name: ta.Optional[str] = '.versions'
-
-    @staticmethod
-    def parse(s: str) -> ta.Mapping[str, str]:
-        return {
-            k: v
-            for l in s.splitlines()
-            if (sl := l.split('#')[0].strip())
-            for k, _, v in (sl.partition('='),)
-        }
-
-    @cached_nullary
-    def contents(self) -> ta.Mapping[str, str]:
-        if not self.name or not os.path.exists(self.name):
-            return {}
-        with open(self.name) as f:
-            s = f.read()
-        return self.parse(s)
-
-    @staticmethod
-    def get_pythons(d: ta.Mapping[str, str]) -> ta.Mapping[str, str]:
-        pfx = 'PYTHON_'
-        return {k[len(pfx):].lower(): v for k, v in d.items() if k.startswith(pfx)}
-
-    @cached_nullary
-    def pythons(self) -> ta.Mapping[str, str]:
-        return self.get_pythons(self.contents())
-
-
-##
-
-
 @cached_nullary
 def _script_rel_path() -> str:
     cwd = os.getcwd()

omdev/tools/sqlrepl.py

@@ -1,3 +1,10 @@
+"""
+TODO:
+ - sqlite
+ - unify-ish with omlish.sql
+"""
+import abc
+import configparser
 import dataclasses as dc
 import os.path
 import shutil
@@ -76,104 +83,197 @@ def spec_from_cfg(cfg: ta.Mapping[str, ta.Any], prefix: str) -> ServerSpec:
     )
 
 
-@lang.cached_function
-def _maybe_warn_pgcli_keyring() -> None:
-    import pgcli.config
+##
+
+
+@dc.dataclass(frozen=True)
+class ReplArgs:
+    spec: ServerSpec
+    extra_args: ta.Sequence[str] | None = None  # noqa
+
+    _: dc.KW_ONLY
+
+    exe: ta.Sequence[str] | None = None
+
+    no_dbcli: bool = False
+    no_import: bool = False
+    no_uv: bool = False
+    dbcli_version: str | None = None
+
+
+class ReplRunner(lang.Abstract):
+    def __init__(self, args: ReplArgs) -> None:
+        super().__init__()
+
+        self._args = args
+
+    exe_name: ta.ClassVar[str]
+    dbcli_name: ta.ClassVar[str | None] = None
+
+    #
+
+    class Exe(ta.NamedTuple):
+        args: ta.Sequence[str]
+        is_dbcli: bool
+
+    @lang.cached_function
+    def exe(self) -> Exe:
+        if self._args.exe is not None:
+            if isinstance(self._args.exe, str):
+                return ReplRunner.Exe([self._args.exe], False)
+            else:
+                return ReplRunner.Exe(list(self._args.exe), False)
+
+        def default():
+            return ReplRunner.Exe([check.not_none(shutil.which(self.exe_name))], False)
+
+        if self._args.no_dbcli or self.dbcli_name is None:
+            return default()
+
+        if not self._args.no_import:
+            main_mod = self.dbcli_name + '.main'
+
+            try:
+                __import__(main_mod)
+            except ImportError:
+                pass
+            else:
+                return ReplRunner.Exe([sys.executable, '-m', main_mod], True)
+
+        if not self._args.no_uv and (uv_exe := shutil.which('uv')) is not None:
+            uv_arg = self.dbcli_name
+            if self._args.dbcli_version is not None:
+                uv_arg += f'@{self._args.dbcli_version}'
+
+            return ReplRunner.Exe([uv_exe, 'tool', 'run', uv_arg], True)
+
+        return default()
+
+    #
+
+    @abc.abstractmethod
+    def build_args(self) -> ta.Sequence[str]:
+        raise NotImplementedError
+
+    def pre_exec(self) -> None:
+        pass
+
+    #
+
+    def run(self) -> ta.NoReturn:
+        lst: list[str] = [
+            *self.exe().args,
+            *self.build_args(),
+        ]
+
+        self.pre_exec()
+
+        os.execvp(lst[0], lst)
+
+
+class MysqlReplRunner(ReplRunner):
+    dbcli_name = 'mycli'
+    exe_name = 'mysql'
+
+    def build_args(self) -> ta.Sequence[str]:
+        lst: list[str] = []
+
+        if self._args.spec.username:
+            lst.extend(['--user', self._args.spec.username])
+
+        lst.extend(['--host', self._args.spec.host])
+        if not self.exe().is_dbcli:
+            lst.append('--protocol=TCP')
+        if self._args.spec.port:
+            lst.extend(['--port', str(self._args.spec.port)])
+
+        if self._args.spec.db:
+            lst.append(self._args.spec.db)
+
+        lst.extend(self._args.extra_args or [])
+
+        return lst
+
+    def pre_exec(self) -> None:
+        super().pre_exec()
+
+        if self._args.spec.password:
+            os.environ['MYSQL_PWD'] = self._args.spec.password
+
+
+class PostgresReplRunner(ReplRunner):
+    dbcli_name = 'pgcli'
+    exe_name = 'psql'
+
+    def build_args(self) -> ta.Sequence[str]:
+        lst: list[str] = []
+
+        if self._args.spec.username:
+            lst.extend(['--username', self._args.spec.username])
+
+        if self._args.spec.host:
+            lst.extend(['--host', self._args.spec.host])
+        if self._args.spec.port:
+            lst.extend(['--port', str(self._args.spec.port)])
+
+        if self._args.spec.db:
+            lst.append(self._args.spec.db)
+
+        lst.extend(self._args.extra_args or [])
+
+        return lst
+
+    def _maybe_warn_keyring(self) -> None:
+        if 'XDG_CONFIG_HOME' in os.environ:
+            cfg_dir = f'{os.path.expanduser(os.environ["XDG_CONFIG_HOME"])}/pgcli/'
+        else:
+            cfg_dir = os.path.expanduser('~/.config/pgcli/')
+        cfg_path = os.path.join(cfg_dir, 'config')
+
+        if os.path.exists(cfg_path):
+            cfg = configparser.ConfigParser()
+            cfg.read(cfg_path)
+
+            if cfg.has_section('main') and not cfg.getboolean('main', 'keyring', fallback=True):
+                return
 
-    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',
+            'set `[main] keyring = False` in ~/.config/pgcli/config',
         )
 
+    def pre_exec(self) -> None:
+        super().pre_exec()
 
-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)
+        self._maybe_warn_keyring()
+
+        if self._args.spec.password:
+            os.environ['PGPASSWORD'] = self._args.spec.password
+
+
+##
 
 
 class Cli(ap.Cli):
     @ap.cmd(
-        ap.arg('--no-dbcli', action='store_true'),
         ap.arg('dialect'),
         ap.arg('target'),
         ap.arg('args', nargs='*'),
+        ap.arg('--no-dbcli', action='store_true'),
+        ap.arg('--no-import', action='store_true'),
+        ap.arg('--no-uv', action='store_true'),
     )
     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':
@@ -185,13 +285,24 @@ class Cli(ap.Cli):
         else:
             spec = spec_from_cfg(cfg, r)
 
+        repl_args = ReplArgs(
+            spec,
+            self.args.args,
+            no_dbcli=self.args.no_dbcli,
+            no_import=self.args.no_import,
+            no_uv=self.args.no_uv,
+        )
+
+        repl_run: ReplRunner
         if dialect == 'mysql':
-            exec_mysql_cli(spec, *self.args.args, no_dbcli=self.args.no_dbcli)
+            repl_run = MysqlReplRunner(repl_args)
         elif dialect == 'postgres':
-            exec_postgres_cli(spec, *self.args.args, no_dbcli=self.args.no_dbcli)
+            repl_run = PostgresReplRunner(repl_args)
         else:
             raise Exception(f'unhandled dialect: {dialect=}')
 
+        repl_run.run()
+
 
 # @omlish-manifest
 _CLI_MODULE = CliModule('sqlrepl', __name__)