omlish 0.0.0.dev95__tar.gz → 0.0.0.dev97__tar.gz

{omlish-0.0.0.dev95/omlish.egg-info → omlish-0.0.0.dev97}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev95
+Version: 0.0.0.dev97
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev95 → omlish-0.0.0.dev97}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev95'
-__revision__ = '40763ed67700ccfb9317c5f357737baadbc16159'
+__version__ = '0.0.0.dev97'
+__revision__ = '4adbb70454ff03be6ca98d986f768deff72e6e7f'
 
 
 #

{omlish-0.0.0.dev95 → omlish-0.0.0.dev97}/omlish/bootstrap/diag.py

@@ -169,17 +169,12 @@ class TimebombBootstrap(ContextBootstrap['TimebombBootstrap.Config']):
 class PycharmBootstrap(SimpleBootstrap['PycharmBootstrap.Config']):
     @dc.dataclass(frozen=True)
     class Config(Bootstrap.Config):
-        debug_host: ta.Optional[str] = None
-        debug_port: ta.Optional[int] = None
-        version: ta.Optional[str] = None
+        debug: ta.Optional[str] = None
 
     def run(self) -> None:
-        if self._config.debug_port is not None:
-            diagpc.pycharm_remote_debugger_attach(
-                self._config.debug_host,
-                self._config.debug_port,
-                version=self._config.version,
-            )
+        if self._config.debug is not None:
+            prd = diagpc.PycharmRemoteDebugger.parse(self._config.debug)
+            diagpc.pycharm_remote_debugger_attach(prd)
 
 
 ##

{omlish-0.0.0.dev95 → omlish-0.0.0.dev97}/omlish/diag/pycharm/__init__.py

@@ -1,4 +1,5 @@
 from .pycharm import (  # noqa
+    PycharmRemoteDebugger,
     get_pycharm_version,
     is_pycharm_hosted,
     pycharm_remote_debugger_attach,

{omlish-0.0.0.dev95 → omlish-0.0.0.dev97}/omlish/diag/pycharm/pycharm.py

@@ -1,5 +1,7 @@
+import dataclasses as dc
 import os.path
 import plistlib
+import re
 import subprocess
 import sys
 import typing as ta
@@ -106,12 +108,33 @@ def _import_pydevd_pycharm(*, version: str | None = None) -> ta.Any:
     return pydevd_pycharm
 
 
-def pycharm_remote_debugger_attach(
-        host: str | None,
-        port: int,
-        *,
-        version: str | None = None,
-) -> None:
+@dc.dataclass(frozen=True)
+class PycharmRemoteDebugger:
+    host: str | None
+    port: int
+    version: str | None = None
+
+    def __str__(self) -> str:
+        return ''.join([
+            f'@{self.version}:' if self.version is not None else '',
+            f'{self.host}:' if self.host is not None else '',
+            str(self.port),
+        ])
+
+    @classmethod
+    def parse(cls, s: str) -> 'PycharmRemoteDebugger':
+        if (m := re.fullmatch(r'(@(?P<version>[^:]+):)?((?P<host>[^:]+):)?(?P<port>\d+)', s)) is None:
+            raise ValueError(s)
+        gd = m.groupdict()
+        return cls(
+            host=gd.get('host'),
+            port=int(gd['port']),
+            version=gd.get('version'),
+        )
+
+
+def pycharm_remote_debugger_attach(prd: PycharmRemoteDebugger) -> None:
+    host = prd.host
     if host is None:
         if (
                 sys.platform == 'linux' and
@@ -122,6 +145,7 @@ def pycharm_remote_debugger_attach(
         else:
             host = 'localhost'
 
+    version = prd.version
     if version is None and host in ('localhost', '127.0.0.1'):
         version = get_pycharm_version()
 
@@ -132,7 +156,7 @@ def pycharm_remote_debugger_attach(
 
     pydevd_pycharm.settrace(
         host,
-        port=port,
+        port=prd.port,
         stdoutToServer=True,
         stderrToServer=True,
     )

{omlish-0.0.0.dev95 → omlish-0.0.0.dev97}/omlish/term.py

@@ -1,10 +1,18 @@
 import enum
 import re
+import sys
+import time
 import typing as ta
 
 from . import lang
 
 
+T = ta.TypeVar('T')
+
+
+##
+
+
 ESC = '\x1b'
 BEL = '\x07'
 
@@ -207,6 +215,136 @@ BG24_RGB = ControlSequence(
     lambda r, g, b: CSI + '48;2;' + str(r) + ';' + str(g) + ';' + str(b) + 'm',
     '24-Bit Background Color (RGB)')
 
+##
+
+
+class ProgressBar:
+    """
+    TODO:
+     - ProgressBarRenderer
+     - right-justify
+     - ProgressBarGroup
+     - animate
+    """
+
+    def __init__(
+            self,
+            total: int | None = None,
+            *,
+            length: int = 40,
+            interval: float = .2,
+            start_time: float | None = None,
+            out: ta.TextIO | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._total = total
+        self._length = length
+        self._interval = interval
+        if start_time is None:
+            start_time = time.time()
+        self._start_time = start_time
+        if out is None:
+            out = sys.stdout
+        self._out = out
+
+        self._i = 0
+        self._elapsed = 0.
+        self._last_print = 0.
+
+    def render(
+            self,
+            *,
+            complete: bool = False,
+    ) -> str:
+        iter_per_sec = self._i / self._elapsed if self._elapsed > 0 else 0
+
+        if self._total is not None:
+            remaining = (self._total - self._i) / iter_per_sec if iter_per_sec > 0 else 0
+            done = int(self._length * self._i / self._total)
+
+            bar = f'[{"█" * done}{"." * (self._length - done)}]'
+            info_parts = [
+                f'{self._i}/{self._total}',
+                f'{iter_per_sec:.2f} it/s',
+                f'{self._elapsed:.2f}s elapsed',
+                f'{remaining:.2f}s left',
+            ]
+
+        else:
+            bar = f'[{("█" if complete else "?") * self._length}]'
+            info_parts = [
+                f'{self._i}',
+                f'{iter_per_sec:.2f} it/s',
+                f'{self._elapsed:.2f}s elapsed',
+            ]
+
+        info = ' | '.join(info_parts)
+        return f'{bar} {info}'
+
+    def print(
+            self,
+            *,
+            now: float | None = None,
+            **kwargs: ta.Any,
+    ) -> None:
+        if now is None:
+            now = time.time()
+
+        line = self.render(**kwargs)
+        self._out.write(f'\033[2K\033[G{line}')
+        self._out.flush()
+
+        self._last_print = now
+
+    def update(
+            self,
+            n: int = 1,
+            *,
+            now: float | None = None,
+            silent: bool = False,
+    ) -> None:
+        if now is None:
+            now = time.time()
+
+        self._i += n
+        self._elapsed = now - self._start_time
+
+        if not silent:
+            if now - self._last_print >= self._interval:
+                self.print(now=now)
+
+
+def progress_bar(
+        seq: ta.Iterable[T],
+        *,
+        no_tty_check: bool = False,
+        total: int | None = None,
+        **kwargs: ta.Any,
+) -> ta.Generator[T, None, None]:
+    if not no_tty_check and not sys.stdout.isatty():
+        yield from seq
+        return
+
+    if total is None:
+        if isinstance(seq, ta.Sized):
+            total = len(seq)
+
+    pb = ProgressBar(
+        total=total,
+        **kwargs,
+    )
+
+    for item in seq:
+        pb.update()
+        yield item
+
+    pb.print(complete=True)
+    sys.stdout.write('\n')
+
+
+##
+
 
 def main() -> None:
     import sys

{omlish-0.0.0.dev95 → omlish-0.0.0.dev97/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev95
+Version: 0.0.0.dev97
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev95 → omlish-0.0.0.dev97}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '>=3.12'
-version = '0.0.0.dev95'
+version = '0.0.0.dev97'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',