omdev 0.0.0.dev157__py3-none-any.whl → 0.0.0.dev159__py3-none-any.whl

omdev/scripts/pyproject.py

@@ -115,7 +115,7 @@ CallableVersionOperator = ta.Callable[['Version', str], bool]
 # ../../omlish/argparse/cli.py
 ArgparseCommandFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
 
-# ../../omlish/lite/subprocesses.py
+# ../../omlish/subprocesses.py
 SubprocessChannelOption = ta.Literal['pipe', 'stdout', 'devnull']  # ta.TypeAlias
 
 
@@ -2328,6 +2328,13 @@ json_dump_compact: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON
 json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_COMPACT_KWARGS)
 
 
+########################################
+# ../../../omlish/lite/logs.py
+
+
+log = logging.getLogger(__name__)
+
+
 ########################################
 # ../../../omlish/lite/reflect.py
 
@@ -2450,6 +2457,116 @@ def format_num_bytes(num_bytes: int) -> str:
     return f'{num_bytes / 1024 ** (len(FORMAT_NUM_BYTES_SUFFIXES) - 1):.2f}{FORMAT_NUM_BYTES_SUFFIXES[-1]}'
 
 
+########################################
+# ../../../omlish/logs/filters.py
+
+
+class TidLogFilter(logging.Filter):
+    def filter(self, record):
+        record.tid = threading.get_native_id()
+        return True
+
+
+########################################
+# ../../../omlish/logs/proxy.py
+
+
+class ProxyLogFilterer(logging.Filterer):
+    def __init__(self, underlying: logging.Filterer) -> None:  # noqa
+        self._underlying = underlying
+
+    @property
+    def underlying(self) -> logging.Filterer:
+        return self._underlying
+
+    @property
+    def filters(self):
+        return self._underlying.filters
+
+    @filters.setter
+    def filters(self, filters):
+        self._underlying.filters = filters
+
+    def addFilter(self, filter):  # noqa
+        self._underlying.addFilter(filter)
+
+    def removeFilter(self, filter):  # noqa
+        self._underlying.removeFilter(filter)
+
+    def filter(self, record):
+        return self._underlying.filter(record)
+
+
+class ProxyLogHandler(ProxyLogFilterer, logging.Handler):
+    def __init__(self, underlying: logging.Handler) -> None:  # noqa
+        ProxyLogFilterer.__init__(self, underlying)
+
+    _underlying: logging.Handler
+
+    @property
+    def underlying(self) -> logging.Handler:
+        return self._underlying
+
+    def get_name(self):
+        return self._underlying.get_name()
+
+    def set_name(self, name):
+        self._underlying.set_name(name)
+
+    @property
+    def name(self):
+        return self._underlying.name
+
+    @property
+    def level(self):
+        return self._underlying.level
+
+    @level.setter
+    def level(self, level):
+        self._underlying.level = level
+
+    @property
+    def formatter(self):
+        return self._underlying.formatter
+
+    @formatter.setter
+    def formatter(self, formatter):
+        self._underlying.formatter = formatter
+
+    def createLock(self):
+        self._underlying.createLock()
+
+    def acquire(self):
+        self._underlying.acquire()
+
+    def release(self):
+        self._underlying.release()
+
+    def setLevel(self, level):
+        self._underlying.setLevel(level)
+
+    def format(self, record):
+        return self._underlying.format(record)
+
+    def emit(self, record):
+        self._underlying.emit(record)
+
+    def handle(self, record):
+        return self._underlying.handle(record)
+
+    def setFormatter(self, fmt):
+        self._underlying.setFormatter(fmt)
+
+    def flush(self):
+        self._underlying.flush()
+
+    def close(self):
+        self._underlying.close()
+
+    def handleError(self, record):
+        self._underlying.handleError(record)
+
+
 ########################################
 # ../../cexts/magic.py
 
@@ -3207,6 +3324,83 @@ class SpecifierSet(BaseSpecifier):
             return iter(filtered)
 
 
+########################################
+# ../reqs.py
+"""
+TODO:
+ - embed pip._internal.req.parse_requirements, add additional env stuff? breaks compat with raw pip
+"""
+
+
+class RequirementsRewriter:
+    def __init__(
+            self,
+            venv: ta.Optional[str] = None,
+    ) -> None:
+        super().__init__()
+        self._venv = venv
+
+    @cached_nullary
+    def _tmp_dir(self) -> str:
+        return tempfile.mkdtemp('-omlish-reqs')
+
+    VENV_MAGIC = '# @omlish-venv'
+
+    def rewrite_file(self, in_file: str) -> str:
+        with open(in_file) as f:
+            src = f.read()
+
+        in_lines = src.splitlines(keepends=True)
+        out_lines = []
+
+        for l in in_lines:
+            if self.VENV_MAGIC in l:
+                lp, _, rp = l.partition(self.VENV_MAGIC)
+                rp = rp.partition('#')[0]
+                omit = False
+                for v in rp.split():
+                    if v[0] == '!':
+                        if self._venv is not None and self._venv == v[1:]:
+                            omit = True
+                            break
+                    else:
+                        raise NotImplementedError
+
+                if omit:
+                    out_lines.append('# OMITTED:  ' + l)
+                    continue
+
+            out_req = self.rewrite(l.rstrip('\n'), for_file=True)
+            out_lines.append(out_req + '\n')
+
+        out_file = os.path.join(self._tmp_dir(), os.path.basename(in_file))
+        if os.path.exists(out_file):
+            raise Exception(f'file exists: {out_file}')
+
+        with open(out_file, 'w') as f:
+            f.write(''.join(out_lines))
+        log.info('Rewrote requirements file %s to %s', in_file, out_file)
+        return out_file
+
+    def rewrite(self, in_req: str, *, for_file: bool = False) -> str:
+        if in_req.strip().startswith('-r'):
+            l = in_req.strip()
+            lp, _, rp = l.partition(' ')
+            if lp == '-r':
+                inc_in_file, _, rest = rp.partition(' ')
+            else:
+                inc_in_file, rest = lp[2:], rp
+
+            inc_out_file = self.rewrite_file(inc_in_file)
+            if for_file:
+                return ' '.join(['-r ', inc_out_file, rest])
+            else:
+                return '-r' + inc_out_file
+
+        else:
+            return in_req
+
+
 ########################################
 # ../../../omlish/argparse/cli.py
 """
@@ -3482,311 +3676,41 @@ class ArgparseCli:
 
 
 ########################################
-# ../../../omlish/lite/logs.py
+# ../../../omlish/lite/marshal.py
 """
 TODO:
- - translate json keys
- - debug
+ - pickle stdlib objs? have to pin to 3.8 pickle protocol, will be cross-version
+ - namedtuple
+ - literals
+ - newtypes?
 """
 
 
-log = logging.getLogger(__name__)
-
-
 ##
 
 
-class TidLogFilter(logging.Filter):
-
-    def filter(self, record):
-        record.tid = threading.get_native_id()
-        return True
+@dc.dataclass(frozen=True)
+class ObjMarshalOptions:
+    raw_bytes: bool = False
+    nonstrict_dataclasses: bool = False
 
 
-##
+class ObjMarshaler(abc.ABC):
+    @abc.abstractmethod
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        raise NotImplementedError
 
+    @abc.abstractmethod
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        raise NotImplementedError
 
-class JsonLogFormatter(logging.Formatter):
 
-    KEYS: ta.Mapping[str, bool] = {
-        'name': False,
-        'msg': False,
-        'args': False,
-        'levelname': False,
-        'levelno': False,
-        'pathname': False,
-        'filename': False,
-        'module': False,
-        'exc_info': True,
-        'exc_text': True,
-        'stack_info': True,
-        'lineno': False,
-        'funcName': False,
-        'created': False,
-        'msecs': False,
-        'relativeCreated': False,
-        'thread': False,
-        'threadName': False,
-        'processName': False,
-        'process': False,
-    }
+class NopObjMarshaler(ObjMarshaler):
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return o
 
-    def format(self, record: logging.LogRecord) -> str:
-        dct = {
-            k: v
-            for k, o in self.KEYS.items()
-            for v in [getattr(record, k)]
-            if not (o and v is None)
-        }
-        return json_dumps_compact(dct)
-
-
-##
-
-
-STANDARD_LOG_FORMAT_PARTS = [
-    ('asctime', '%(asctime)-15s'),
-    ('process', 'pid=%(process)-6s'),
-    ('thread', 'tid=%(thread)x'),
-    ('levelname', '%(levelname)s'),
-    ('name', '%(name)s'),
-    ('separator', '::'),
-    ('message', '%(message)s'),
-]
-
-
-class StandardLogFormatter(logging.Formatter):
-
-    @staticmethod
-    def build_log_format(parts: ta.Iterable[ta.Tuple[str, str]]) -> str:
-        return ' '.join(v for k, v in parts)
-
-    converter = datetime.datetime.fromtimestamp  # type: ignore
-
-    def formatTime(self, record, datefmt=None):
-        ct = self.converter(record.created)  # type: ignore
-        if datefmt:
-            return ct.strftime(datefmt)  # noqa
-        else:
-            t = ct.strftime('%Y-%m-%d %H:%M:%S')
-            return '%s.%03d' % (t, record.msecs)  # noqa
-
-
-##
-
-
-class ProxyLogFilterer(logging.Filterer):
-    def __init__(self, underlying: logging.Filterer) -> None:  # noqa
-        self._underlying = underlying
-
-    @property
-    def underlying(self) -> logging.Filterer:
-        return self._underlying
-
-    @property
-    def filters(self):
-        return self._underlying.filters
-
-    @filters.setter
-    def filters(self, filters):
-        self._underlying.filters = filters
-
-    def addFilter(self, filter):  # noqa
-        self._underlying.addFilter(filter)
-
-    def removeFilter(self, filter):  # noqa
-        self._underlying.removeFilter(filter)
-
-    def filter(self, record):
-        return self._underlying.filter(record)
-
-
-class ProxyLogHandler(ProxyLogFilterer, logging.Handler):
-    def __init__(self, underlying: logging.Handler) -> None:  # noqa
-        ProxyLogFilterer.__init__(self, underlying)
-
-    _underlying: logging.Handler
-
-    @property
-    def underlying(self) -> logging.Handler:
-        return self._underlying
-
-    def get_name(self):
-        return self._underlying.get_name()
-
-    def set_name(self, name):
-        self._underlying.set_name(name)
-
-    @property
-    def name(self):
-        return self._underlying.name
-
-    @property
-    def level(self):
-        return self._underlying.level
-
-    @level.setter
-    def level(self, level):
-        self._underlying.level = level
-
-    @property
-    def formatter(self):
-        return self._underlying.formatter
-
-    @formatter.setter
-    def formatter(self, formatter):
-        self._underlying.formatter = formatter
-
-    def createLock(self):
-        self._underlying.createLock()
-
-    def acquire(self):
-        self._underlying.acquire()
-
-    def release(self):
-        self._underlying.release()
-
-    def setLevel(self, level):
-        self._underlying.setLevel(level)
-
-    def format(self, record):
-        return self._underlying.format(record)
-
-    def emit(self, record):
-        self._underlying.emit(record)
-
-    def handle(self, record):
-        return self._underlying.handle(record)
-
-    def setFormatter(self, fmt):
-        self._underlying.setFormatter(fmt)
-
-    def flush(self):
-        self._underlying.flush()
-
-    def close(self):
-        self._underlying.close()
-
-    def handleError(self, record):
-        self._underlying.handleError(record)
-
-
-##
-
-
-class StandardLogHandler(ProxyLogHandler):
-    pass
-
-
-##
-
-
-@contextlib.contextmanager
-def _locking_logging_module_lock() -> ta.Iterator[None]:
-    if hasattr(logging, '_acquireLock'):
-        logging._acquireLock()  # noqa
-        try:
-            yield
-        finally:
-            logging._releaseLock()  # type: ignore  # noqa
-
-    elif hasattr(logging, '_lock'):
-        # https://github.com/python/cpython/commit/74723e11109a320e628898817ab449b3dad9ee96
-        with logging._lock:  # noqa
-            yield
-
-    else:
-        raise Exception("Can't find lock in logging module")
-
-
-def configure_standard_logging(
-        level: ta.Union[int, str] = logging.INFO,
-        *,
-        json: bool = False,
-        target: ta.Optional[logging.Logger] = None,
-        force: bool = False,
-        handler_factory: ta.Optional[ta.Callable[[], logging.Handler]] = None,
-) -> ta.Optional[StandardLogHandler]:
-    with _locking_logging_module_lock():
-        if target is None:
-            target = logging.root
-
-        #
-
-        if not force:
-            if any(isinstance(h, StandardLogHandler) for h in list(target.handlers)):
-                return None
-
-        #
-
-        if handler_factory is not None:
-            handler = handler_factory()
-        else:
-            handler = logging.StreamHandler()
-
-        #
-
-        formatter: logging.Formatter
-        if json:
-            formatter = JsonLogFormatter()
-        else:
-            formatter = StandardLogFormatter(StandardLogFormatter.build_log_format(STANDARD_LOG_FORMAT_PARTS))
-        handler.setFormatter(formatter)
-
-        #
-
-        handler.addFilter(TidLogFilter())
-
-        #
-
-        target.addHandler(handler)
-
-        #
-
-        if level is not None:
-            target.setLevel(level)
-
-        #
-
-        return StandardLogHandler(handler)
-
-
-########################################
-# ../../../omlish/lite/marshal.py
-"""
-TODO:
- - pickle stdlib objs? have to pin to 3.8 pickle protocol, will be cross-version
- - namedtuple
- - literals
- - newtypes?
-"""
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class ObjMarshalOptions:
-    raw_bytes: bool = False
-    nonstrict_dataclasses: bool = False
-
-
-class ObjMarshaler(abc.ABC):
-    @abc.abstractmethod
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        raise NotImplementedError
-
-
-class NopObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return o
-
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return o
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return o
 
 
 @dc.dataclass()
@@ -4205,12 +4129,66 @@ def is_debugger_attached() -> bool:
     return any(frame[1].endswith('pydevd.py') for frame in inspect.stack())
 
 
-REQUIRED_PYTHON_VERSION = (3, 8)
+LITE_REQUIRED_PYTHON_VERSION = (3, 8)
 
 
-def check_runtime_version() -> None:
-    if sys.version_info < REQUIRED_PYTHON_VERSION:
-        raise OSError(f'Requires python {REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
+def check_lite_runtime_version() -> None:
+    if sys.version_info < LITE_REQUIRED_PYTHON_VERSION:
+        raise OSError(f'Requires python {LITE_REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
+
+
+########################################
+# ../../../omlish/logs/json.py
+"""
+TODO:
+ - translate json keys
+"""
+
+
+class JsonLogFormatter(logging.Formatter):
+    KEYS: ta.Mapping[str, bool] = {
+        'name': False,
+        'msg': False,
+        'args': False,
+        'levelname': False,
+        'levelno': False,
+        'pathname': False,
+        'filename': False,
+        'module': False,
+        'exc_info': True,
+        'exc_text': True,
+        'stack_info': True,
+        'lineno': False,
+        'funcName': False,
+        'created': False,
+        'msecs': False,
+        'relativeCreated': False,
+        'thread': False,
+        'threadName': False,
+        'processName': False,
+        'process': False,
+    }
+
+    def __init__(
+            self,
+            *args: ta.Any,
+            json_dumps: ta.Optional[ta.Callable[[ta.Any], str]] = None,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        if json_dumps is None:
+            json_dumps = json_dumps_compact
+        self._json_dumps = json_dumps
+
+    def format(self, record: logging.LogRecord) -> str:
+        dct = {
+            k: v
+            for k, o in self.KEYS.items()
+            for v in [getattr(record, k)]
+            if not (o and v is None)
+        }
+        return self._json_dumps(dct)
 
 
 ########################################
@@ -4405,84 +4383,129 @@ class PyprojectConfigPreparer:
 
 
 ########################################
-# ../reqs.py
+# ../../../omlish/logs/standard.py
 """
 TODO:
- - embed pip._internal.req.parse_requirements, add additional env stuff? breaks compat with raw pip
+ - structured
+ - prefixed
+ - debug
+ - optional noisy? noisy will never be lite - some kinda configure_standard callback mechanism?
 """
 
 
-class RequirementsRewriter:
-    def __init__(
-            self,
-            venv: ta.Optional[str] = None,
-    ) -> None:
-        super().__init__()
-        self._venv = venv
+##
 
-    @cached_nullary
-    def _tmp_dir(self) -> str:
-        return tempfile.mkdtemp('-omlish-reqs')
 
-    VENV_MAGIC = '# @omlish-venv'
+STANDARD_LOG_FORMAT_PARTS = [
+    ('asctime', '%(asctime)-15s'),
+    ('process', 'pid=%(process)-6s'),
+    ('thread', 'tid=%(thread)x'),
+    ('levelname', '%(levelname)s'),
+    ('name', '%(name)s'),
+    ('separator', '::'),
+    ('message', '%(message)s'),
+]
 
-    def rewrite_file(self, in_file: str) -> str:
-        with open(in_file) as f:
-            src = f.read()
 
-        in_lines = src.splitlines(keepends=True)
-        out_lines = []
+class StandardLogFormatter(logging.Formatter):
+    @staticmethod
+    def build_log_format(parts: ta.Iterable[ta.Tuple[str, str]]) -> str:
+        return ' '.join(v for k, v in parts)
 
-        for l in in_lines:
-            if self.VENV_MAGIC in l:
-                lp, _, rp = l.partition(self.VENV_MAGIC)
-                rp = rp.partition('#')[0]
-                omit = False
-                for v in rp.split():
-                    if v[0] == '!':
-                        if self._venv is not None and self._venv == v[1:]:
-                            omit = True
-                            break
-                    else:
-                        raise NotImplementedError
+    converter = datetime.datetime.fromtimestamp  # type: ignore
 
-                if omit:
-                    out_lines.append('# OMITTED:  ' + l)
-                    continue
+    def formatTime(self, record, datefmt=None):
+        ct = self.converter(record.created)  # type: ignore
+        if datefmt:
+            return ct.strftime(datefmt)  # noqa
+        else:
+            t = ct.strftime('%Y-%m-%d %H:%M:%S')
+            return '%s.%03d' % (t, record.msecs)  # noqa
 
-            out_req = self.rewrite(l.rstrip('\n'), for_file=True)
-            out_lines.append(out_req + '\n')
 
-        out_file = os.path.join(self._tmp_dir(), os.path.basename(in_file))
-        if os.path.exists(out_file):
-            raise Exception(f'file exists: {out_file}')
+##
 
-        with open(out_file, 'w') as f:
-            f.write(''.join(out_lines))
-        log.info('Rewrote requirements file %s to %s', in_file, out_file)
-        return out_file
 
-    def rewrite(self, in_req: str, *, for_file: bool = False) -> str:
-        if in_req.strip().startswith('-r'):
-            l = in_req.strip()
-            lp, _, rp = l.partition(' ')
-            if lp == '-r':
-                inc_in_file, _, rest = rp.partition(' ')
-            else:
-                inc_in_file, rest = lp[2:], rp
+class StandardConfiguredLogHandler(ProxyLogHandler):
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError('This class serves only as a marker and should not be subclassed.')
+
+
+##
+
+
+@contextlib.contextmanager
+def _locking_logging_module_lock() -> ta.Iterator[None]:
+    if hasattr(logging, '_acquireLock'):
+        logging._acquireLock()  # noqa
+        try:
+            yield
+        finally:
+            logging._releaseLock()  # type: ignore  # noqa
+
+    elif hasattr(logging, '_lock'):
+        # https://github.com/python/cpython/commit/74723e11109a320e628898817ab449b3dad9ee96
+        with logging._lock:  # noqa
+            yield
+
+    else:
+        raise Exception("Can't find lock in logging module")
+
+
+def configure_standard_logging(
+        level: ta.Union[int, str] = logging.INFO,
+        *,
+        json: bool = False,
+        target: ta.Optional[logging.Logger] = None,
+        force: bool = False,
+        handler_factory: ta.Optional[ta.Callable[[], logging.Handler]] = None,
+) -> ta.Optional[StandardConfiguredLogHandler]:
+    with _locking_logging_module_lock():
+        if target is None:
+            target = logging.root
+
+        #
+
+        if not force:
+            if any(isinstance(h, StandardConfiguredLogHandler) for h in list(target.handlers)):
+                return None
+
+        #
+
+        if handler_factory is not None:
+            handler = handler_factory()
+        else:
+            handler = logging.StreamHandler()
+
+        #
+
+        formatter: logging.Formatter
+        if json:
+            formatter = JsonLogFormatter()
+        else:
+            formatter = StandardLogFormatter(StandardLogFormatter.build_log_format(STANDARD_LOG_FORMAT_PARTS))
+        handler.setFormatter(formatter)
+
+        #
+
+        handler.addFilter(TidLogFilter())
+
+        #
+
+        target.addHandler(handler)
+
+        #
 
-            inc_out_file = self.rewrite_file(inc_in_file)
-            if for_file:
-                return ' '.join(['-r ', inc_out_file, rest])
-            else:
-                return '-r' + inc_out_file
+        if level is not None:
+            target.setLevel(level)
 
-        else:
-            return in_req
+        #
+
+        return StandardConfiguredLogHandler(handler)
 
 
 ########################################
-# ../../../omlish/lite/subprocesses.py
+# ../../../omlish/subprocesses.py
 
 
 ##
@@ -4533,8 +4556,8 @@ def subprocess_close(
 ##
 
 
-class AbstractSubprocesses(abc.ABC):  # noqa
-    DEFAULT_LOGGER: ta.ClassVar[ta.Optional[logging.Logger]] = log
+class BaseSubprocesses(abc.ABC):  # noqa
+    DEFAULT_LOGGER: ta.ClassVar[ta.Optional[logging.Logger]] = None
 
     def __init__(
             self,
@@ -4547,6 +4570,9 @@ class AbstractSubprocesses(abc.ABC):  # noqa
         self._log = log if log is not None else self.DEFAULT_LOGGER
         self._try_exceptions = try_exceptions if try_exceptions is not None else self.DEFAULT_TRY_EXCEPTIONS
 
+    def set_logger(self, log: ta.Optional[logging.Logger]) -> None:
+        self._log = log
+
     #
 
     def prepare_args(
@@ -4658,23 +4684,25 @@ class AbstractSubprocesses(abc.ABC):  # noqa
 ##
 
 
-class Subprocesses(AbstractSubprocesses):
+class AbstractSubprocesses(BaseSubprocesses, abc.ABC):
+    @abc.abstractmethod
     def check_call(
             self,
             *cmd: str,
             stdout: ta.Any = sys.stderr,
             **kwargs: ta.Any,
     ) -> None:
-        with self.prepare_and_wrap(*cmd, stdout=stdout, **kwargs) as (cmd, kwargs):  # noqa
-            subprocess.check_call(cmd, **kwargs)
+        raise NotImplementedError
 
+    @abc.abstractmethod
     def check_output(
             self,
             *cmd: str,
             **kwargs: ta.Any,
     ) -> bytes:
-        with self.prepare_and_wrap(*cmd, **kwargs) as (cmd, kwargs):  # noqa
-            return subprocess.check_output(cmd, **kwargs)
+        raise NotImplementedError
+
+    #
 
     def check_output_str(
             self,
@@ -4716,412 +4744,142 @@ class Subprocesses(AbstractSubprocesses):
             return ret.decode().strip()
 
 
-subprocesses = Subprocesses()
+##
 
 
-########################################
-# ../../git.py
-"""
-git status
-  --porcelain=v1
-  --ignore-submodules
-  2>/dev/null
-"""
+class Subprocesses(AbstractSubprocesses):
+    def check_call(
+            self,
+            *cmd: str,
+            stdout: ta.Any = sys.stderr,
+            **kwargs: ta.Any,
+    ) -> None:
+        with self.prepare_and_wrap(*cmd, stdout=stdout, **kwargs) as (cmd, kwargs):  # noqa
+            subprocess.check_call(cmd, **kwargs)
+
+    def check_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bytes:
+        with self.prepare_and_wrap(*cmd, **kwargs) as (cmd, kwargs):  # noqa
+            return subprocess.check_output(cmd, **kwargs)
+
+
+subprocesses = Subprocesses()
 
 
 ##
 
 
-def git_clone_subtree(
-        *,
-        base_dir: str,
-        repo_url: str,
-        repo_dir: str,
-        branch: ta.Optional[str] = None,
-        rev: ta.Optional[str] = None,
-        repo_subtrees: ta.Sequence[str],
-) -> None:
-    if not bool(branch) ^ bool(rev):
-        raise ValueError('must set branch or rev')
+class AbstractAsyncSubprocesses(BaseSubprocesses):
+    @abc.abstractmethod
+    async def check_call(
+            self,
+            *cmd: str,
+            stdout: ta.Any = sys.stderr,
+            **kwargs: ta.Any,
+    ) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def check_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bytes:
+        raise NotImplementedError
 
-    if isinstance(repo_subtrees, str):
-        raise TypeError(repo_subtrees)
+    #
 
-    git_opts = [
-        '-c', 'advice.detachedHead=false',
-    ]
+    async def check_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> str:
+        return (await self.check_output(*cmd, **kwargs)).decode().strip()
 
-    subprocess.check_call(
-        subprocess_maybe_shell_wrap_exec(
-            'git',
-            *git_opts,
-            'clone',
-            '-n',
-            '--depth=1',
-            '--filter=tree:0',
-            *(['-b', branch] if branch else []),
-            '--single-branch',
-            repo_url,
-            repo_dir,
-        ),
-        cwd=base_dir,
-    )
+    #
 
-    rd = os.path.join(base_dir, repo_dir)
-    subprocess.check_call(
-        subprocess_maybe_shell_wrap_exec(
-            'git',
-            *git_opts,
-            'sparse-checkout',
-            'set',
-            '--no-cone',
-            *repo_subtrees,
-        ),
-        cwd=rd,
-    )
+    async def try_call(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bool:
+        if isinstance(await self.async_try_fn(self.check_call, *cmd, **kwargs), Exception):
+            return False
+        else:
+            return True
 
-    subprocess.check_call(
-        subprocess_maybe_shell_wrap_exec(
-            'git',
-            *git_opts,
-            'checkout',
-            *([rev] if rev else []),
-        ),
-        cwd=rd,
-    )
+    async def try_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[bytes]:
+        if isinstance(ret := await self.async_try_fn(self.check_output, *cmd, **kwargs), Exception):
+            return None
+        else:
+            return ret
+
+    async def try_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[str]:
+        if (ret := await self.try_output(*cmd, **kwargs)) is None:
+            return None
+        else:
+            return ret.decode().strip()
+
+
+########################################
+# ../../git/revisions.py
 
 
 def get_git_revision(
         *,
         cwd: ta.Optional[str] = None,
 ) -> ta.Optional[str]:
-    subprocess.check_output(subprocess_maybe_shell_wrap_exec('git', '--version'))
+    subprocesses.check_output('git', '--version')
 
     if cwd is None:
         cwd = os.getcwd()
 
     if subprocess.run(  # noqa
-        subprocess_maybe_shell_wrap_exec(
-            'git',
-            'rev-parse',
-            '--is-inside-work-tree',
-        ),
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
+            subprocess_maybe_shell_wrap_exec(
+                'git',
+                'rev-parse',
+                '--is-inside-work-tree',
+            ),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
     ).returncode:
         return None
 
-    has_untracked = bool(subprocess.check_output(subprocess_maybe_shell_wrap_exec(
+    has_untracked = bool(subprocesses.check_output(
         'git',
         'ls-files',
         '.',
         '--exclude-standard',
         '--others',
-    ), cwd=cwd).decode().strip())
+        cwd=cwd,
+    ).decode().strip())
 
-    dirty_rev = subprocess.check_output(subprocess_maybe_shell_wrap_exec(
+    dirty_rev = subprocesses.check_output(
         'git',
         'describe',
         '--match=NeVeRmAtCh',
         '--always',
         '--abbrev=40',
         '--dirty',
-    ), cwd=cwd).decode().strip()
-
-    return dirty_rev + ('-untracked' if has_untracked else '')
-
-
-##
-
-
-_GIT_STATUS_LINE_ESCAPE_CODES: ta.Mapping[str, str] = {
-    '\\': '\\',
-    '"': '"',
-    'n': '\n',
-    't': '\t',
-}
-
-
-def yield_git_status_line_fields(l: str) -> ta.Iterator[str]:
-    def find_any(chars: str, start: int = 0) -> int:
-        ret = -1
-        for c in chars:
-            if (found := l.find(c, start)) >= 0 and (ret < 0 or ret > found):
-                ret = found
-        return ret
-
-    p = 0
-    while True:
-        if l[p] == '"':
-            p += 1
-            s = []
-            while (n := find_any('\\"', p)) > 0:
-                if (c := l[n]) == '\\':
-                    s.append(l[p:n])
-                    s.append(_GIT_STATUS_LINE_ESCAPE_CODES[l[n + 1]])
-                    p = n + 2
-                elif c == '"':
-                    s.append(l[p:n])
-                    p = n
-                    break
-                else:
-                    raise ValueError(l)
-
-            if l[p] != '"':
-                raise ValueError(l)
-
-            yield ''.join(s)
-
-            p += 1
-            if p == len(l):
-                return
-            elif l[p] != ' ':
-                raise ValueError(l)
-
-            p += 1
-
-        else:
-            if (e := l.find(' ', p)) < 0:
-                yield l[p:]
-                return
-
-            yield l[p:e]
-            p = e + 1
-
-
-"""
-When merge is occurring and was successful, or outside of a merge situation, X shows the status of the index and Y shows
-the status of the working tree:
--------------------------------------------------
-X         Y       Meaning
--------------------------------------------------
-          [AMD]   not updated
-M         [ MTD]  updated in index
-T         [ MTD]  type changed in index
-A         [ MTD]  added to index
-D                 deleted from index
-R         [ MTD]  renamed in index
-C         [ MTD]  copied in index
-[MTARC]           index and work tree matches
-[ MTARC]  M       work tree changed since index
-[ MTARC]  T       type changed in work tree since index
-[ MTARC]  D       deleted in work tree
-          R       renamed in work tree
-          C       copied in work tree
-
-When merge conflict has occurred and has not yet been resolved, X and Y show the state introduced by each head of the
-merge, relative to the common ancestor:
--------------------------------------------------
-X         Y       Meaning
--------------------------------------------------
-D         D       unmerged, both deleted
-A         U       unmerged, added by us
-U         D       unmerged, deleted by them
-U         A       unmerged, added by them
-D         U       unmerged, deleted by us
-A         A       unmerged, both added
-U         U       unmerged, both modified
-
-When path is untracked, X and Y are always the same, since they are unknown to the index:
--------------------------------------------------
-X         Y       Meaning
--------------------------------------------------
-?         ?       untracked
-!         !       ignored
-
-Submodules have more state and instead report
-
- - M = the submodule has a different HEAD than recorded in the index
- - m = the submodule has modified content
- - ? = the submodule has untracked files
-
-This is since modified content or untracked files in a submodule cannot be added via git add in the superproject to
-prepare a commit. m and ? are applied recursively. For example if a nested submodule in a submodule contains an
-untracked file, this is reported as ? as well.
-"""  # noqa
-
-
-class GitStatusState(enum.Enum):
-    UNMODIFIED = ' '
-    MODIFIED = 'M'
-    FILE_TYPE_CHANGED = 'T'
-    ADDED = 'A'
-    DELETED = 'D'
-    RENAMED = 'R'
-    COPIED = 'C'
-    UPDATED_BUT_UNMERGED = 'U'
-    UNTRACKED = '?'
-    IGNORED = '!'
-    SUBMODULE_MODIFIED_CONTENT = 'm'
-
-
-_UNMERGED_GIT_STATUS_STATES: ta.FrozenSet[GitStatusState] = frozenset([
-    GitStatusState.UPDATED_BUT_UNMERGED,
-])
-
-_UNMERGED_GIT_STATUS_STATE_PAIRS: ta.FrozenSet[ta.Tuple[GitStatusState, GitStatusState]] = frozenset([
-    (GitStatusState.ADDED, GitStatusState.ADDED),
-    (GitStatusState.DELETED, GitStatusState.DELETED),
-])
-
-
-@dc.dataclass(frozen=True)
-class GitStatusItem:
-    x: GitStatusState
-    y: GitStatusState
-
-    a: str
-    b: ta.Optional[str]
-
-    @property
-    def is_unmerged(self) -> bool:
-        return (
-            self.x in _UNMERGED_GIT_STATUS_STATE_PAIRS or
-            self.y in _UNMERGED_GIT_STATUS_STATE_PAIRS or
-            (self.x, self.y) in _UNMERGED_GIT_STATUS_STATE_PAIRS
-        )
-
-    def __repr__(self) -> str:
-        return (
-            f'{self.__class__.__name__}('
-            f'x={self.x.name}, '
-            f'y={self.y.name}, '
-            f'a={self.a!r}' +
-            (f', b={self.b!r}' if self.b is not None else '') +
-            ')'
-        )
-
-
-def parse_git_status_line(l: str) -> GitStatusItem:
-    if len(l) < 3 or l[2] != ' ':
-        raise ValueError(l)
-    x, y = l[0], l[1]
-
-    fields = list(yield_git_status_line_fields(l[3:]))
-    if len(fields) == 1:
-        a, b = fields[0], None
-    elif len(fields) == 3:
-        check.state(fields[1] == '->', l)
-        a, b = fields[0], fields[2]
-    else:
-        raise ValueError(l)
-
-    return GitStatusItem(
-        GitStatusState(x),
-        GitStatusState(y),
-        a,
-        b,
-    )
-
-
-class GitStatus(ta.Sequence[GitStatusItem]):
-    def __init__(self, lines: ta.Iterable[GitStatusItem]) -> None:
-        super().__init__()
-
-        self._lst = list(lines)
-
-        by_x: ta.Dict[GitStatusState, list[GitStatusItem]] = {}
-        by_y: ta.Dict[GitStatusState, list[GitStatusItem]] = {}
-
-        by_a: ta.Dict[str, GitStatusItem] = {}
-        by_b: ta.Dict[str, GitStatusItem] = {}
-
-        for l in self._lst:
-            by_x.setdefault(l.x, []).append(l)
-            by_y.setdefault(l.y, []).append(l)
-
-            if l.a in by_a:
-                raise KeyError(l.a)
-            by_a[l.a] = l
-
-            if l.b is not None:
-                if l.b in by_b:
-                    raise KeyError(l.b)
-                by_b[l.b] = l
-
-        self._by_x = by_x
-        self._by_y = by_y
-
-        self._by_a = by_a
-        self._by_b = by_b
-
-        self._has_unmerged = any(l.is_unmerged for l in self)
-
-    #
-
-    def __iter__(self) -> ta.Iterator[GitStatusItem]:
-        return iter(self._lst)
-
-    def __getitem__(self, index):
-        return self._lst[index]
-
-    def __len__(self) -> int:
-        return len(self._lst)
-
-    #
-
-    @property
-    def by_x(self) -> ta.Mapping[GitStatusState, ta.Sequence[GitStatusItem]]:
-        return self._by_x
-
-    @property
-    def by_y(self) -> ta.Mapping[GitStatusState, ta.Sequence[GitStatusItem]]:
-        return self._by_y
-
-    @property
-    def by_a(self) -> ta.Mapping[str, GitStatusItem]:
-        return self._by_a
-
-    @property
-    def by_b(self) -> ta.Mapping[str, GitStatusItem]:
-        return self._by_b
-
-    #
-
-    @property
-    def has_unmerged(self) -> bool:
-        return self._has_unmerged
-
-    @property
-    def has_staged(self) -> bool:
-        return any(l.x != GitStatusState.UNMODIFIED for l in self._lst)
-
-    @property
-    def has_dirty(self) -> bool:
-        return any(l.y != GitStatusState.UNMODIFIED for l in self._lst)
-
-
-def parse_git_status(s: str) -> GitStatus:
-    return GitStatus(parse_git_status_line(l) for l in s.splitlines())
-
-
-def get_git_status(
-        *,
-        cwd: ta.Optional[str] = None,
-        ignore_submodules: bool = False,
-        verbose: bool = False,
-) -> GitStatus:
-    if cwd is None:
-        cwd = os.getcwd()
-
-    proc = subprocess.run(  # type: ignore
-        subprocess_maybe_shell_wrap_exec(
-            'git',
-            'status',
-            '--porcelain=v1',
-            *(['--ignore-submodules'] if ignore_submodules else []),
-        ),
         cwd=cwd,
-        stdout=subprocess.PIPE,
-        **(dict(stderr=subprocess.PIPE) if not verbose else {}),
-        check=True,
-    )
+    ).decode().strip()
 
-    return parse_git_status(proc.stdout.decode())  # noqa
+    return dirty_rev + ('-untracked' if has_untracked else '')
 
 
 ########################################
-# ../../../omlish/lite/asyncio/subprocesses.py
+# ../../../omlish/asyncs/asyncio/subprocesses.py
 
 
 ##
@@ -5132,6 +4890,8 @@ class AsyncioProcessCommunicator:
             self,
             proc: asyncio.subprocess.Process,
             loop: ta.Optional[ta.Any] = None,
+            *,
+            log: ta.Optional[logging.Logger] = None,
     ) -> None:
         super().__init__()
 
@@ -5140,6 +4900,7 @@ class AsyncioProcessCommunicator:
 
         self._proc = proc
         self._loop = loop
+        self._log = log
 
         self._transport: asyncio.base_subprocess.BaseSubprocessTransport = check.isinstance(
             proc._transport,  # type: ignore  # noqa
@@ -5155,19 +4916,19 @@ class AsyncioProcessCommunicator:
         try:
             if input is not None:
                 stdin.write(input)
-                if self._debug:
-                    log.debug('%r communicate: feed stdin (%s bytes)', self, len(input))
+                if self._debug and self._log is not None:
+                    self._log.debug('%r communicate: feed stdin (%s bytes)', self, len(input))
 
             await stdin.drain()
 
         except (BrokenPipeError, ConnectionResetError) as exc:
             # communicate() ignores BrokenPipeError and ConnectionResetError. write() and drain() can raise these
             # exceptions.
-            if self._debug:
-                log.debug('%r communicate: stdin got %r', self, exc)
+            if self._debug and self._log is not None:
+                self._log.debug('%r communicate: stdin got %r', self, exc)
 
-        if self._debug:
-            log.debug('%r communicate: close stdin', self)
+        if self._debug and self._log is not None:
+            self._log.debug('%r communicate: close stdin', self)
 
         stdin.close()
 
@@ -5183,15 +4944,15 @@ class AsyncioProcessCommunicator:
             check.equal(fd, 1)
             stream = check.not_none(self._proc.stdout)
 
-        if self._debug:
+        if self._debug and self._log is not None:
             name = 'stdout' if fd == 1 else 'stderr'
-            log.debug('%r communicate: read %s', self, name)
+            self._log.debug('%r communicate: read %s', self, name)
 
         output = await stream.read()
 
-        if self._debug:
+        if self._debug and self._log is not None:
             name = 'stdout' if fd == 1 else 'stderr'
-            log.debug('%r communicate: close %s', self, name)
+            self._log.debug('%r communicate: close %s', self, name)
 
         transport.close()
 
@@ -5240,7 +5001,7 @@ class AsyncioProcessCommunicator:
 ##
 
 
-class AsyncioSubprocesses(AbstractSubprocesses):
+class AsyncioSubprocesses(AbstractAsyncSubprocesses):
     async def communicate(
             self,
             proc: asyncio.subprocess.Process,
@@ -5337,45 +5098,6 @@ class AsyncioSubprocesses(AbstractSubprocesses):
         with self.prepare_and_wrap(*cmd, stdout=subprocess.PIPE, check=True, **kwargs) as (cmd, kwargs):  # noqa
             return check.not_none((await self.run(*cmd, **kwargs)).stdout)
 
-    async def check_output_str(
-            self,
-            *cmd: str,
-            **kwargs: ta.Any,
-    ) -> str:
-        return (await self.check_output(*cmd, **kwargs)).decode().strip()
-
-    #
-
-    async def try_call(
-            self,
-            *cmd: str,
-            **kwargs: ta.Any,
-    ) -> bool:
-        if isinstance(await self.async_try_fn(self.check_call, *cmd, **kwargs), Exception):
-            return False
-        else:
-            return True
-
-    async def try_output(
-            self,
-            *cmd: str,
-            **kwargs: ta.Any,
-    ) -> ta.Optional[bytes]:
-        if isinstance(ret := await self.async_try_fn(self.check_output, *cmd, **kwargs), Exception):
-            return None
-        else:
-            return ret
-
-    async def try_output_str(
-            self,
-            *cmd: str,
-            **kwargs: ta.Any,
-    ) -> ta.Optional[str]:
-        if (ret := await self.try_output(*cmd, **kwargs)) is None:
-            return None
-        else:
-            return ret.decode().strip()
-
 
 asyncio_subprocesses = AsyncioSubprocesses()
 
@@ -7215,7 +6937,7 @@ class PyprojectCli(ArgparseCli):
 
 
 async def _async_main(argv: ta.Optional[ta.Sequence[str]] = None) -> None:
-    check_runtime_version()
+    check_lite_runtime_version()
     configure_standard_logging()
 
     await PyprojectCli(argv).async_cli_run()