omdev 0.0.0.dev441__py3-none-any.whl → 0.0.0.dev443__py3-none-any.whl

omdev/interp/venvs.py

@@ -21,6 +21,7 @@ from .types import InterpSpecifier
 class InterpVenvConfig:
     interp: ta.Optional[str] = None
     requires: ta.Optional[ta.Sequence[str]] = None
+    requires_pats: ta.Optional[ta.Sequence[str]] = None
     use_uv: ta.Optional[bool] = None
 
 

omdev/packaging/requires.py

@@ -33,6 +33,12 @@ from omlish.lite.check import check
 from .specifiers import Specifier
 
 
+RequiresMarkerVar = ta.Union['RequiresVariable', 'RequiresValue']  # ta.TypeAlias
+
+RequiresMarkerAtom = ta.Union['RequiresMarkerItem', ta.Sequence['RequiresMarkerAtom']]  # ta.TypeAlias
+RequiresMarkerList = ta.Sequence[ta.Union['RequiresMarkerList', 'RequiresMarkerAtom', str]]  # ta.TypeAlias
+
+
 ##
 
 
@@ -229,12 +235,6 @@ class RequiresOp(RequiresNode):
         return str(self)
 
 
-RequiresMarkerVar = ta.Union['RequiresVariable', 'RequiresValue']
-
-RequiresMarkerAtom = ta.Union['RequiresMarkerItem', ta.Sequence['RequiresMarkerAtom']]
-RequiresMarkerList = ta.Sequence[ta.Union['RequiresMarkerList', 'RequiresMarkerAtom', str]]
-
-
 class RequiresMarkerItem(ta.NamedTuple):
     l: ta.Union[RequiresVariable, RequiresValue]
     op: RequiresOp

omdev/pyproject/reqs.py

@@ -4,12 +4,16 @@ TODO:
 """
 # ruff: noqa: UP007 UP045
 import os.path
+import re
 import tempfile
 import typing as ta
 
 from omlish.lite.cached import cached_nullary
 from omlish.logs.modules import get_module_logger
 
+from ..packaging.requires import RequiresParserSyntaxError
+from ..packaging.requires import parse_requirement
+
 
 log = get_module_logger(globals())  # noqa
 
@@ -20,11 +24,14 @@ log = get_module_logger(globals())  # noqa
 class RequirementsRewriter:
     def __init__(
             self,
+            *,
             venv: ta.Optional[str] = None,
+            only_pats: ta.Optional[ta.Sequence[re.Pattern]] = None,
     ) -> None:
         super().__init__()
 
         self._venv = venv
+        self._only_pats = only_pats
 
     @cached_nullary
     def _tmp_dir(self) -> str:
@@ -40,17 +47,32 @@ class RequirementsRewriter:
         out_lines = []
 
         for l in in_lines:
-            if self.VENV_MAGIC in l:
-                lp, _, rp = l.partition(self.VENV_MAGIC)
-                rp = rp.partition('#')[0]
+            if l.split('#')[0].strip():
                 omit = False
-                for v in rp.split():
-                    if v[0] == '!':
-                        if self._venv is not None and self._venv == v[1:]:
-                            omit = True
-                            break
+
+                if self.VENV_MAGIC in l:
+                    lp, _, rp = l.partition(self.VENV_MAGIC)
+                    rp = rp.partition('#')[0]
+                    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 (
+                        not omit and
+                        (ops := self._only_pats) is not None and
+                        not l.strip().startswith('-')
+                ):
+                    try:
+                        pr = parse_requirement(l.split('#')[0].strip())
+                    except RequiresParserSyntaxError:
+                        pass
                     else:
-                        raise NotImplementedError
+                        if not any(op.fullmatch(pr.name) for op in ops):
+                            omit = True
 
                 if omit:
                     out_lines.append('# OMITTED:  ' + l)

omdev/pyproject/venvs.py

@@ -1,6 +1,7 @@
 # ruff: noqa: UP006 UP007 UP045
 import glob
 import os.path
+import re
 import typing as ta
 
 from omlish.lite.cached import async_cached_nullary
@@ -42,7 +43,13 @@ class Venv:
 
     @cached_nullary
     def _iv(self) -> InterpVenv:
-        rr = RequirementsRewriter(self._name)
+        rr = RequirementsRewriter(
+            venv=self._name,
+            only_pats=(
+                [re.compile(p) for p in self._cfg.requires_pats]
+                if self._cfg.requires_pats is not None else None
+            ),
+        )
 
         return InterpVenv(
             self.dir_name,

omdev/scripts/ci.py

@@ -4718,8 +4718,6 @@ class _JustMaybe(_Maybe[T]):
     __slots__ = ('_v', '_hash')
 
     def __init__(self, v: T) -> None:
-        super().__init__()
-
         self._v = v
 
     @property

omdev/scripts/interp.py

@@ -2630,8 +2630,6 @@ class _JustMaybe(_Maybe[T]):
     __slots__ = ('_v', '_hash')
 
     def __init__(self, v: T) -> None:
-        super().__init__()
-
         self._v = v
 
     @property

omdev/scripts/lib/inject.py

@@ -896,8 +896,6 @@ class _JustMaybe(_Maybe[T]):
     __slots__ = ('_v', '_hash')
 
     def __init__(self, v: T) -> None:
-        super().__init__()
-
         self._v = v
 
     @property

omdev/scripts/pyproject.py

@@ -27,6 +27,7 @@ See:
 """
 import abc
 import argparse
+import ast
 import asyncio
 import asyncio.base_subprocess
 import asyncio.subprocess
@@ -137,6 +138,11 @@ LoggingExcInfo = ta.Union[BaseException, LoggingExcInfoTuple]  # ta.TypeAlias
 LoggingExcInfoArg = ta.Union[LoggingExcInfo, bool, None]  # ta.TypeAlias
 LoggingContextInfo = ta.Any  # ta.TypeAlias
 
+# ../packaging/requires.py
+RequiresMarkerVar = ta.Union['RequiresVariable', 'RequiresValue']  # ta.TypeAlias
+RequiresMarkerAtom = ta.Union['RequiresMarkerItem', ta.Sequence['RequiresMarkerAtom']]  # ta.TypeAlias
+RequiresMarkerList = ta.Sequence[ta.Union['RequiresMarkerList', 'RequiresMarkerAtom', str]]  # ta.TypeAlias
+
 # ../../omlish/asyncs/asyncio/timeouts.py
 AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
 
@@ -5221,8 +5227,6 @@ class _JustMaybe(_Maybe[T]):
     __slots__ = ('_v', '_hash')
 
     def __init__(self, v: T) -> None:
-        super().__init__()
-
         self._v = v
 
     @property
@@ -6050,6 +6054,488 @@ class Interp:
     version: InterpVersion
 
 
+########################################
+# ../../packaging/requires.py
+# Copyright (c) Donald Stufft and individual contributors.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+# following conditions are met:
+#
+#     1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
+#        following disclaimer.
+#
+#     2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+#        following disclaimer in the documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. This file is dual licensed under the terms of the
+# Apache License, Version 2.0, and the BSD License. See the LICENSE file in the root of this repository for complete
+# details.
+# https://github.com/pypa/packaging/blob/cf2cbe2aec28f87c6228a6fb136c27931c9af407/src/packaging/_parser.py#L65
+
+
+##
+
+
+@dc.dataclass()
+class RequiresToken:
+    name: str
+    text: str
+    position: int
+
+
+class RequiresParserSyntaxError(Exception):
+    def __init__(
+        self,
+        message: str,
+        *,
+        source: str,
+        span: ta.Tuple[int, int],
+    ) -> None:
+        self.span = span
+        self.message = message
+        self.source = source
+
+        super().__init__()
+
+    def __str__(self) -> str:
+        marker = ' ' * self.span[0] + '~' * (self.span[1] - self.span[0]) + '^'
+        return '\n    '.join([self.message, self.source, marker])
+
+
+REQUIRES_DEFAULT_RULES: ta.Dict[str, ta.Union[str, ta.Pattern[str]]] = {
+    'LEFT_PARENTHESIS': r'\(',
+    'RIGHT_PARENTHESIS': r'\)',
+    'LEFT_BRACKET': r'\[',
+    'RIGHT_BRACKET': r'\]',
+    'SEMICOLON': r';',
+    'COMMA': r',',
+    'QUOTED_STRING': re.compile(
+        r"""
+            (
+                ('[^']*')
+                |
+                ("[^"]*")
+            )
+        """,
+        re.VERBOSE,
+    ),
+    'OP': r'(===|==|~=|!=|<=|>=|<|>)',
+    'BOOLOP': r'\b(or|and)\b',
+    'IN': r'\bin\b',
+    'NOT': r'\bnot\b',
+    'VARIABLE': re.compile(
+        r"""
+            \b(
+                python_version
+                |python_full_version
+                |os[._]name
+                |sys[._]platform
+                |platform_(release|system)
+                |platform[._](version|machine|python_implementation)
+                |python_implementation
+                |implementation_(name|version)
+                |extra
+            )\b
+        """,
+        re.VERBOSE,
+    ),
+    'SPECIFIER': re.compile(
+        Specifier._operator_regex_str + Specifier._version_regex_str,  # noqa
+        re.VERBOSE | re.IGNORECASE,
+    ),
+    'AT': r'\@',
+    'URL': r'[^ \t]+',
+    'IDENTIFIER': r'\b[a-zA-Z0-9][a-zA-Z0-9._-]*\b',
+    'VERSION_PREFIX_TRAIL': r'\.\*',
+    'VERSION_LOCAL_LABEL_TRAIL': r'\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*',
+    'WS': r'[ \t]+',
+    'END': r'$',
+}
+
+
+class RequiresTokenizer:
+    def __init__(
+        self,
+        source: str,
+        *,
+        rules: ta.Dict[str, ta.Union[str, ta.Pattern[str]]],
+    ) -> None:
+        super().__init__()
+
+        self.source = source
+        self.rules: ta.Dict[str, ta.Pattern[str]] = {name: re.compile(pattern) for name, pattern in rules.items()}
+        self.next_token: ta.Optional[RequiresToken] = None
+        self.position = 0
+
+    def consume(self, name: str) -> None:
+        if self.check(name):
+            self.read()
+
+    def check(self, name: str, *, peek: bool = False) -> bool:
+        check.state(self.next_token is None, f'Cannot check for {name!r}, already have {self.next_token!r}')
+        check.state(name in self.rules, f'Unknown token name: {name!r}')
+
+        expression = self.rules[name]
+
+        match = expression.match(self.source, self.position)
+        if match is None:
+            return False
+        if not peek:
+            self.next_token = RequiresToken(name, match[0], self.position)
+        return True
+
+    def expect(self, name: str, *, expected: str) -> RequiresToken:
+        if not self.check(name):
+            raise self.raise_syntax_error(f'Expected {expected}')
+        return self.read()
+
+    def read(self) -> RequiresToken:
+        token = self.next_token
+        check.state(token is not None)
+
+        self.position += len(check.not_none(token).text)
+        self.next_token = None
+
+        return check.not_none(token)
+
+    def raise_syntax_error(
+        self,
+        message: str,
+        *,
+        span_start: ta.Optional[int] = None,
+        span_end: ta.Optional[int] = None,
+    ) -> ta.NoReturn:
+        span = (
+            self.position if span_start is None else span_start,
+            self.position if span_end is None else span_end,
+        )
+        raise RequiresParserSyntaxError(
+            message,
+            source=self.source,
+            span=span,
+        )
+
+    @contextlib.contextmanager
+    def enclosing_tokens(self, open_token: str, close_token: str, *, around: str) -> ta.Iterator[None]:
+        if self.check(open_token):
+            open_position = self.position
+            self.read()
+        else:
+            open_position = None
+
+        yield
+
+        if open_position is None:
+            return
+
+        if not self.check(close_token):
+            self.raise_syntax_error(
+                f'Expected matching {close_token} for {open_token}, after {around}',
+                span_start=open_position,
+            )
+
+        self.read()
+
+
+@dc.dataclass(frozen=True)
+class RequiresNode:
+    value: str
+
+    def __str__(self) -> str:
+        return self.value
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}('{self}')>"
+
+    def serialize(self) -> str:
+        raise NotImplementedError
+
+
+@dc.dataclass(frozen=True)
+class RequiresVariable(RequiresNode):
+    def serialize(self) -> str:
+        return str(self)
+
+
+@dc.dataclass(frozen=True)
+class RequiresValue(RequiresNode):
+    def serialize(self) -> str:
+        return f'"{self}"'
+
+
+@dc.dataclass(frozen=True)
+class RequiresOp(RequiresNode):
+    def serialize(self) -> str:
+        return str(self)
+
+
+class RequiresMarkerItem(ta.NamedTuple):
+    l: ta.Union[RequiresVariable, RequiresValue]
+    op: RequiresOp
+    r: ta.Union[RequiresVariable, RequiresValue]
+
+
+class ParsedRequirement(ta.NamedTuple):
+    name: str
+    url: str
+    extras: ta.List[str]
+    specifier: str
+    marker: ta.Optional[RequiresMarkerList]
+
+
+def parse_requirement(source: str) -> ParsedRequirement:
+    return _parse_requirement(RequiresTokenizer(source, rules=REQUIRES_DEFAULT_RULES))
+
+
+def _parse_requirement(tokenizer: RequiresTokenizer) -> ParsedRequirement:
+    tokenizer.consume('WS')
+
+    name_token = tokenizer.expect('IDENTIFIER', expected='package name at the start of dependency specifier')
+    name = name_token.text
+    tokenizer.consume('WS')
+
+    extras = _parse_requires_extras(tokenizer)
+    tokenizer.consume('WS')
+
+    url, specifier, marker = _parse_requirement_details(tokenizer)
+    tokenizer.expect('END', expected='end of dependency specifier')
+
+    return ParsedRequirement(name, url, extras, specifier, marker)
+
+
+def _parse_requirement_details(tokenizer: RequiresTokenizer) -> ta.Tuple[str, str, ta.Optional[RequiresMarkerList]]:
+    specifier = ''
+    url = ''
+    marker = None
+
+    if tokenizer.check('AT'):
+        tokenizer.read()
+        tokenizer.consume('WS')
+
+        url_start = tokenizer.position
+        url = tokenizer.expect('URL', expected='URL after @').text
+        if tokenizer.check('END', peek=True):
+            return (url, specifier, marker)
+
+        tokenizer.expect('WS', expected='whitespace after URL')
+
+        # The input might end after whitespace.
+        if tokenizer.check('END', peek=True):
+            return (url, specifier, marker)
+
+        marker = _parse_requirement_marker(
+            tokenizer, span_start=url_start, after='URL and whitespace',
+        )
+    else:
+        specifier_start = tokenizer.position
+        specifier = _parse_requires_specifier(tokenizer)
+        tokenizer.consume('WS')
+
+        if tokenizer.check('END', peek=True):
+            return (url, specifier, marker)
+
+        marker = _parse_requirement_marker(
+            tokenizer,
+            span_start=specifier_start,
+            after=(
+                'version specifier'
+                if specifier
+                else 'name and no valid version specifier'
+            ),
+        )
+
+    return (url, specifier, marker)
+
+
+def _parse_requirement_marker(
+    tokenizer: RequiresTokenizer, *, span_start: int, after: str,
+) -> RequiresMarkerList:
+    if not tokenizer.check('SEMICOLON'):
+        tokenizer.raise_syntax_error(
+            f'Expected end or semicolon (after {after})',
+            span_start=span_start,
+        )
+    tokenizer.read()
+
+    marker = _parse_requires_marker(tokenizer)
+    tokenizer.consume('WS')
+
+    return marker
+
+
+def _parse_requires_extras(tokenizer: RequiresTokenizer) -> ta.List[str]:
+    if not tokenizer.check('LEFT_BRACKET', peek=True):
+        return []
+
+    with tokenizer.enclosing_tokens(
+        'LEFT_BRACKET',
+        'RIGHT_BRACKET',
+        around='extras',
+    ):
+        tokenizer.consume('WS')
+        extras = _parse_requires_extras_list(tokenizer)
+        tokenizer.consume('WS')
+
+    return extras
+
+
+def _parse_requires_extras_list(tokenizer: RequiresTokenizer) -> ta.List[str]:
+    extras: ta.List[str] = []
+
+    if not tokenizer.check('IDENTIFIER'):
+        return extras
+
+    extras.append(tokenizer.read().text)
+
+    while True:
+        tokenizer.consume('WS')
+        if tokenizer.check('IDENTIFIER', peek=True):
+            tokenizer.raise_syntax_error('Expected comma between extra names')
+        elif not tokenizer.check('COMMA'):
+            break
+
+        tokenizer.read()
+        tokenizer.consume('WS')
+
+        extra_token = tokenizer.expect('IDENTIFIER', expected='extra name after comma')
+        extras.append(extra_token.text)
+
+    return extras
+
+
+def _parse_requires_specifier(tokenizer: RequiresTokenizer) -> str:
+    with tokenizer.enclosing_tokens(
+        'LEFT_PARENTHESIS',
+        'RIGHT_PARENTHESIS',
+        around='version specifier',
+    ):
+        tokenizer.consume('WS')
+        parsed_specifiers = _parse_requires_version_many(tokenizer)
+        tokenizer.consume('WS')
+
+    return parsed_specifiers
+
+
+def _parse_requires_version_many(tokenizer: RequiresTokenizer) -> str:
+    parsed_specifiers = ''
+    while tokenizer.check('SPECIFIER'):
+        span_start = tokenizer.position
+        parsed_specifiers += tokenizer.read().text
+        if tokenizer.check('VERSION_PREFIX_TRAIL', peek=True):
+            tokenizer.raise_syntax_error(
+                '.* suffix can only be used with `==` or `!=` operators',
+                span_start=span_start,
+                span_end=tokenizer.position + 1,
+            )
+        if tokenizer.check('VERSION_LOCAL_LABEL_TRAIL', peek=True):
+            tokenizer.raise_syntax_error(
+                'Local version label can only be used with `==` or `!=` operators',
+                span_start=span_start,
+                span_end=tokenizer.position,
+            )
+        tokenizer.consume('WS')
+        if not tokenizer.check('COMMA'):
+            break
+        parsed_specifiers += tokenizer.read().text
+        tokenizer.consume('WS')
+
+    return parsed_specifiers
+
+
+def parse_requires_marker(source: str) -> RequiresMarkerList:
+    return _parse_requires_full_marker(RequiresTokenizer(source, rules=REQUIRES_DEFAULT_RULES))
+
+
+def _parse_requires_full_marker(tokenizer: RequiresTokenizer) -> RequiresMarkerList:
+    retval = _parse_requires_marker(tokenizer)
+    tokenizer.expect('END', expected='end of marker expression')
+    return retval
+
+
+def _parse_requires_marker(tokenizer: RequiresTokenizer) -> RequiresMarkerList:
+    expression = [_parse_requires_marker_atom(tokenizer)]
+    while tokenizer.check('BOOLOP'):
+        token = tokenizer.read()
+        expr_right = _parse_requires_marker_atom(tokenizer)
+        expression.extend((token.text, expr_right))
+    return expression
+
+
+def _parse_requires_marker_atom(tokenizer: RequiresTokenizer) -> RequiresMarkerAtom:
+    tokenizer.consume('WS')
+    if tokenizer.check('LEFT_PARENTHESIS', peek=True):
+        with tokenizer.enclosing_tokens(
+            'LEFT_PARENTHESIS',
+            'RIGHT_PARENTHESIS',
+            around='marker expression',
+        ):
+            tokenizer.consume('WS')
+            marker: RequiresMarkerAtom = _parse_requires_marker(tokenizer)
+            tokenizer.consume('WS')
+    else:
+        marker = _parse_requires_marker_item(tokenizer)
+    tokenizer.consume('WS')
+    return marker
+
+
+def _parse_requires_marker_item(tokenizer: RequiresTokenizer) -> RequiresMarkerItem:
+    tokenizer.consume('WS')
+    marker_var_left = _parse_requires_marker_var(tokenizer)
+    tokenizer.consume('WS')
+    marker_op = _parse_requires_marker_op(tokenizer)
+    tokenizer.consume('WS')
+    marker_var_right = _parse_requires_marker_var(tokenizer)
+    tokenizer.consume('WS')
+    return RequiresMarkerItem(marker_var_left, marker_op, marker_var_right)
+
+
+def _parse_requires_marker_var(tokenizer: RequiresTokenizer) -> RequiresMarkerVar:
+    if tokenizer.check('VARIABLE'):
+        return process_requires_env_var(tokenizer.read().text.replace('.', '_'))
+    elif tokenizer.check('QUOTED_STRING'):
+        return process_requires_python_str(tokenizer.read().text)
+    else:
+        tokenizer.raise_syntax_error(message='Expected a marker variable or quoted string')
+        raise RuntimeError  # noqa
+
+
+def process_requires_env_var(env_var: str) -> RequiresVariable:
+    if env_var in ('platform_python_implementation', 'python_implementation'):
+        return RequiresVariable('platform_python_implementation')
+    else:
+        return RequiresVariable(env_var)
+
+
+def process_requires_python_str(python_str: str) -> RequiresValue:
+    value = ast.literal_eval(python_str)
+    return RequiresValue(str(value))
+
+
+def _parse_requires_marker_op(tokenizer: RequiresTokenizer) -> RequiresOp:
+    if tokenizer.check('IN'):
+        tokenizer.read()
+        return RequiresOp('in')
+    elif tokenizer.check('NOT'):
+        tokenizer.read()
+        tokenizer.expect('WS', expected="whitespace after 'not'")
+        tokenizer.expect('IN', expected="'in' after 'not'")
+        return RequiresOp('not in')
+    elif tokenizer.check('OP'):
+        return RequiresOp(tokenizer.read().text)
+    else:
+        return tokenizer.raise_syntax_error(
+            'Expected marker operator, one of '
+            '<=, <, !=, ==, >=, >, ~=, ===, in, not in',
+        )
+
+
 ########################################
 # ../../../omlish/asyncs/asyncio/timeouts.py
 
@@ -9740,11 +10226,14 @@ log = get_module_logger(globals())  # noqa
 class RequirementsRewriter:
     def __init__(
             self,
+            *,
             venv: ta.Optional[str] = None,
+            only_pats: ta.Optional[ta.Sequence[re.Pattern]] = None,
     ) -> None:
         super().__init__()
 
         self._venv = venv
+        self._only_pats = only_pats
 
     @cached_nullary
     def _tmp_dir(self) -> str:
@@ -9760,17 +10249,32 @@ class RequirementsRewriter:
         out_lines = []
 
         for l in in_lines:
-            if self.VENV_MAGIC in l:
-                lp, _, rp = l.partition(self.VENV_MAGIC)
-                rp = rp.partition('#')[0]
+            if l.split('#')[0].strip():
                 omit = False
-                for v in rp.split():
-                    if v[0] == '!':
-                        if self._venv is not None and self._venv == v[1:]:
-                            omit = True
-                            break
+
+                if self.VENV_MAGIC in l:
+                    lp, _, rp = l.partition(self.VENV_MAGIC)
+                    rp = rp.partition('#')[0]
+                    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 (
+                        not omit and
+                        (ops := self._only_pats) is not None and
+                        not l.strip().startswith('-')
+                ):
+                    try:
+                        pr = parse_requirement(l.split('#')[0].strip())
+                    except RequiresParserSyntaxError:
+                        pass
                     else:
-                        raise NotImplementedError
+                        if not any(op.fullmatch(pr.name) for op in ops):
+                            omit = True
 
                 if omit:
                     out_lines.append('# OMITTED:  ' + l)
@@ -11076,6 +11580,7 @@ def get_default_interp_resolver() -> InterpResolver:
 class InterpVenvConfig:
     interp: ta.Optional[str] = None
     requires: ta.Optional[ta.Sequence[str]] = None
+    requires_pats: ta.Optional[ta.Sequence[str]] = None
     use_uv: ta.Optional[bool] = None
 
 
@@ -11300,7 +11805,13 @@ class Venv:
 
     @cached_nullary
     def _iv(self) -> InterpVenv:
-        rr = RequirementsRewriter(self._name)
+        rr = RequirementsRewriter(
+            venv=self._name,
+            only_pats=(
+                [re.compile(p) for p in self._cfg.requires_pats]
+                if self._cfg.requires_pats is not None else None
+            ),
+        )
 
         return InterpVenv(
             self.dir_name,

{omdev-0.0.0.dev441.dist-info → omdev-0.0.0.dev443.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omdev
-Version: 0.0.0.dev441
+Version: 0.0.0.dev443
 Summary: omdev
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev441
+Requires-Dist: omlish==0.0.0.dev443
 Provides-Extra: all
 Requires-Dist: black~=25.1; extra == "all"
 Requires-Dist: pycparser~=2.23; extra == "all"

{omdev-0.0.0.dev441.dist-info → omdev-0.0.0.dev443.dist-info}/RECORD

@@ -159,7 +159,7 @@ omdev/interp/inject.py,sha256=MOppFILGFCp2f4-2uwmH5fN-7erHI3RyMQJaG0kw0Gc,1569
 omdev/interp/inspect.py,sha256=GLjqRkmNr3H0CZsiFqizM_2yfUL7hSD-BGYysNcVi_Q,3018
 omdev/interp/resolvers.py,sha256=9ExwP0wcQ4mzyTLNurSG4Dg1AQ_IqLfR2ZyqR4VRANE,2590
 omdev/interp/types.py,sha256=Pr0wrVpNasoCw-ThEvKC5LG30Civ7YJ4EONwrwBLpy0,2516
-omdev/interp/venvs.py,sha256=a9lL0C84kNQoofSc7qa59Kgr_KMuyR9hUruKXbu1p98,3306
+omdev/interp/venvs.py,sha256=KAnkHGP8jV8KmiarRl2wuMbya-CEgyN6hEM68irGOxs,3362
 omdev/interp/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/interp/providers/base.py,sha256=zMtzMJIDvaI0q1gtsZTCvFiTc7qdhGbUcXRs6LCBmgo,1333
 omdev/interp/providers/inject.py,sha256=NSDFBQVD3ZR9Mf162XB9_VvTUAXGCRhPcrjVlYcFDJk,857
@@ -208,7 +208,7 @@ omdev/oci/pack/unpacking.py,sha256=tVYw8REKuYd4ciGXwMmXxlp4CRLHdET_gB9ShYh1d_M,6
 omdev/packaging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/packaging/marshal.py,sha256=nr7wN-Pi3FGAuh3HaladzDgOgyQl1-vtmxJ_AUOo4d8,2355
 omdev/packaging/names.py,sha256=-orp16m20gSFeKRiGkRNyqFVV4S1y_Djvjdq_5hNwpY,2533
-omdev/packaging/requires.py,sha256=rgEeJh8shqnFCPBtG_3Tu0vASXsvwK26ikJauFcrz0I,15691
+omdev/packaging/requires.py,sha256=nn4ff8mlgfsdZooKzQjhASFS7mMVUCCmcb-150F0Lcg,15739
 omdev/packaging/revisions.py,sha256=tLNDVtPiygB8mSxwp-kDxeEHhpBzD0jayndjsgUOfkM,5055
 omdev/packaging/specifiers.py,sha256=t6UhvSlmwHmSvqqPb4XnCq9H41HiqeAqRvCUy2DF_P8,17487
 omdev/packaging/versions.py,sha256=SBh4LYfBYVi8SXMoWcOWY-Y3llOF-6cxayVaIM1NXMs,12371
@@ -267,19 +267,19 @@ omdev/pyproject/cli.py,sha256=Umsu2bcJUYeeVXICaZFhKckUBT6VWuYDL4htgCGGQIs,8749
 omdev/pyproject/configs.py,sha256=baNRwHtUW8S8DKCxuKlMbV3Gduujd1PyNURxQ48Nnxk,2813
 omdev/pyproject/inject.py,sha256=Von8_8ofkITLoCEwDHNRAwY0AEdFQg7r2ILS8kcTMuY,325
 omdev/pyproject/pkg.py,sha256=CcWBhsOgim8MYe5ryKDGB8ClRIyiCX6YmYUHRbQ5q_Y,14964
-omdev/pyproject/reqs.py,sha256=LrGr393-yqKbd2K_D-NePrvUIhMDjPG_1cEyQ3qesAM,2480
-omdev/pyproject/venvs.py,sha256=4JIAlNGWNHm4U9OgqG2f1fNwbqEJgQc34bhp9_46MT0,1980
+omdev/pyproject/reqs.py,sha256=DU7NBNpFTjU06VgqRYZj5jZRQxpIWbzL9q9Vm13_o0o,3317
+omdev/pyproject/venvs.py,sha256=PNgfVrGlw9NFKJgUyzyWH5H5nAIzUDPTHRVUNBM0bKs,2187
 omdev/pyproject/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/pyproject/resources/docker-dev.sh,sha256=DHkz5D18jok_oDolfg2mqrvGRWFoCe9GQo04dR1czcc,838
 omdev/pyproject/resources/python.sh,sha256=rFaN4SiJ9hdLDXXsDTwugI6zsw6EPkgYMmtacZeTbvw,749
 omdev/scripts/__init__.py,sha256=MKCvUAEQwsIvwLixwtPlpBqmkMXLCnjjXyAXvVpDwVk,91
-omdev/scripts/ci.py,sha256=FfWskduSL49ktSMNd-e8eUn7K9BmmUtelP8S7g3DIbA,426405
-omdev/scripts/interp.py,sha256=xS894dtPAhB0Dbd4aPfSX5FK6OC2mZLD2N3pPZU4Xoo,168445
-omdev/scripts/pyproject.py,sha256=dMRhPLTKegqIha8ERBmZjdVYgIo57pokpGuXTZt2Zs4,332501
+omdev/scripts/ci.py,sha256=0mb5CkL2y6_ZkMM5xXLEoVkPlh-c5_mb-Ezk45xYdCI,426377
+omdev/scripts/interp.py,sha256=EaKZtDiopNF0i8Wf_DSYyM8c10aAGL41_1FUxCpSjxE,168417
+omdev/scripts/pyproject.py,sha256=8V1bQYXcFRidO2y2adAiyX8VZyG4RMuFzW9DzSqOrgU,349087
 omdev/scripts/slowcat.py,sha256=PwdT-pg62imEEb6kcOozl9_YUi-4KopvjvzWT1OmGb0,2717
 omdev/scripts/tmpexec.py,sha256=t0nErDRALjTk7H0X8ADjZUIDFjlPNzOOokmjCjBHdzs,1431
 omdev/scripts/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omdev/scripts/lib/inject.py,sha256=W-9w85457SPmhzUKRZqLIkULh3arMNto-mdzk5PFlkY,53703
+omdev/scripts/lib/inject.py,sha256=dregGw2IK_yBHR8rUKamV-sRx4YW_NUZAy-xrnfyie0,53675
 omdev/scripts/lib/logs.py,sha256=zRZYc-P9B0-uSETpIXNkNmb874jVvTfKtmUSJ47yZFw,63073
 omdev/scripts/lib/marshal.py,sha256=DOsUKJ1U3mwsNN1Et20cqJUBlzZZcmAv1m-zxMKHYEQ,46835
 omdev/tokens/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -323,9 +323,9 @@ omdev/tools/jsonview/resources/jsonview.js,sha256=faDvXDOXKvEvjOuIlz4D3F2ReQXb_b
 omdev/tools/pawk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/tools/pawk/__main__.py,sha256=VCqeRVnqT1RPEoIrqHFSu4PXVMg4YEgF4qCQm90-eRI,66
 omdev/tools/pawk/pawk.py,sha256=ao5mdrpiSU4AZ8mBozoEaV3UVlmVTnRG9wD9XP70MZE,11429
-omdev-0.0.0.dev441.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omdev-0.0.0.dev441.dist-info/METADATA,sha256=FTG4PsStGupIrFeNgYOgsFRaoF11I53zW83x4oB0pus,5100
-omdev-0.0.0.dev441.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omdev-0.0.0.dev441.dist-info/entry_points.txt,sha256=dHLXFmq5D9B8qUyhRtFqTGWGxlbx3t5ejedjrnXNYLU,33
-omdev-0.0.0.dev441.dist-info/top_level.txt,sha256=1nr7j30fEWgLYHW3lGR9pkdHkb7knv1U1ES1XRNVQ6k,6
-omdev-0.0.0.dev441.dist-info/RECORD,,
+omdev-0.0.0.dev443.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omdev-0.0.0.dev443.dist-info/METADATA,sha256=HFE5R2igDgcjuDWBV73bWvVn73S95-YNrPIGMzCg-xQ,5100
+omdev-0.0.0.dev443.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omdev-0.0.0.dev443.dist-info/entry_points.txt,sha256=dHLXFmq5D9B8qUyhRtFqTGWGxlbx3t5ejedjrnXNYLU,33
+omdev-0.0.0.dev443.dist-info/top_level.txt,sha256=1nr7j30fEWgLYHW3lGR9pkdHkb7knv1U1ES1XRNVQ6k,6
+omdev-0.0.0.dev443.dist-info/RECORD,,