omlish 0.0.0.dev130__py3-none-any.whl → 0.0.0.dev131__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev130'
-__revision__ = '04fd1bb83aa7700c60be8dc97b6530ddf15b6dd7'
+__version__ = '0.0.0.dev131'
+__revision__ = 'd1c2a72e639d89e78ab32d95eaa3e46bf716249c'
 
 
 #
@@ -99,7 +99,7 @@ class Project(ProjectBase):
             'aiosqlite ~= 0.20',
             'asyncpg ~= 0.30',
 
-            'apsw ~= 3.46',
+            'apsw ~= 3.47',
 
             'sqlean.py ~= 3.45',
 

omlish/formats/dotenv.py

@@ -1,3 +1,5 @@
+# @omlish-lite
+# ruff: noqa: UP006 UP007 UP037
 # Copyright (c) 2014, Saurabh Kumar (python-dotenv), 2013, Ted Tieken (django-dotenv-rw), 2013, Jacob Kaplan-Moss
 # (django-dotenv)
 #
@@ -37,13 +39,7 @@ import typing as ta
 ##
 
 
-log = logging.getLogger(__name__)
-
-
-##
-
-
-_posix_variable: ta.Pattern[str] = re.compile(
+_dotenv_posix_variable_pat: ta.Pattern[str] = re.compile(
     r"""
     \$\{
         (?P<name>[^}:]*)
@@ -56,7 +52,7 @@ _posix_variable: ta.Pattern[str] = re.compile(
 )
 
 
-class Atom(metaclass=abc.ABCMeta):
+class DotenvAtom(metaclass=abc.ABCMeta):
     def __ne__(self, other: object) -> bool:
         result = self.__eq__(other)
         if result is NotImplemented:
@@ -64,16 +60,16 @@ class Atom(metaclass=abc.ABCMeta):
         return not result
 
     @abc.abstractmethod
-    def resolve(self, env: ta.Mapping[str, str | None]) -> str: ...
+    def resolve(self, env: ta.Mapping[str, ta.Optional[str]]) -> str: ...
 
 
-class Literal(Atom):
+class DotenvLiteral(DotenvAtom):
     def __init__(self, value: str) -> None:
         super().__init__()
         self.value = value
 
     def __repr__(self) -> str:
-        return f'Literal(value={self.value})'
+        return f'DotenvLiteral(value={self.value})'
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, self.__class__):
@@ -83,18 +79,18 @@ class Literal(Atom):
     def __hash__(self) -> int:
         return hash((self.__class__, self.value))
 
-    def resolve(self, env: ta.Mapping[str, str | None]) -> str:
+    def resolve(self, env: ta.Mapping[str, ta.Optional[str]]) -> str:
         return self.value
 
 
-class Variable(Atom):
-    def __init__(self, name: str, default: str | None) -> None:
+class DotenvVariable(DotenvAtom):
+    def __init__(self, name: str, default: ta.Optional[str]) -> None:
         super().__init__()
         self.name = name
         self.default = default
 
     def __repr__(self) -> str:
-        return f'Variable(name={self.name}, default={self.default})'
+        return f'DotenvVariable(name={self.name}, default={self.default})'
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, self.__class__):
@@ -104,96 +100,96 @@ class Variable(Atom):
     def __hash__(self) -> int:
         return hash((self.__class__, self.name, self.default))
 
-    def resolve(self, env: ta.Mapping[str, str | None]) -> str:
+    def resolve(self, env: ta.Mapping[str, ta.Optional[str]]) -> str:
         default = self.default if self.default is not None else ''
         result = env.get(self.name, default)
         return result if result is not None else ''
 
 
-def parse_variables(value: str) -> ta.Iterator[Atom]:
+def parse_dotenv_variables(value: str) -> ta.Iterator[DotenvAtom]:
     cursor = 0
 
-    for match in _posix_variable.finditer(value):
+    for match in _dotenv_posix_variable_pat.finditer(value):
         (start, end) = match.span()
         name = match['name']
         default = match['default']
 
         if start > cursor:
-            yield Literal(value=value[cursor:start])
+            yield DotenvLiteral(value=value[cursor:start])
 
-        yield Variable(name=name, default=default)
+        yield DotenvVariable(name=name, default=default)
         cursor = end
 
     length = len(value)
     if cursor < length:
-        yield Literal(value=value[cursor:length])
+        yield DotenvLiteral(value=value[cursor:length])
 
 
 ##
 
 
-def _make_regex(string: str, extra_flags: int = 0) -> ta.Pattern[str]:
+def _make_dotenv_regex(string: str, extra_flags: int = 0) -> ta.Pattern[str]:
     return re.compile(string, re.UNICODE | extra_flags)
 
 
-_newline = _make_regex(r'(\r\n|\n|\r)')
-_multiline_whitespace = _make_regex(r'\s*', extra_flags=re.MULTILINE)
-_whitespace = _make_regex(r'[^\S\r\n]*')
-_export = _make_regex(r'(?:export[^\S\r\n]+)?')
-_single_quoted_key = _make_regex(r"'([^']+)'")
-_unquoted_key = _make_regex(r'([^=\#\s]+)')
-_equal_sign = _make_regex(r'(=[^\S\r\n]*)')
-_single_quoted_value = _make_regex(r"'((?:\\'|[^'])*)'")
-_double_quoted_value = _make_regex(r'"((?:\\"|[^"])*)"')
-_unquoted_value = _make_regex(r'([^\r\n]*)')
-_comment = _make_regex(r'(?:[^\S\r\n]*#[^\r\n]*)?')
-_end_of_line = _make_regex(r'[^\S\r\n]*(?:\r\n|\n|\r|$)')
-_rest_of_line = _make_regex(r'[^\r\n]*(?:\r|\n|\r\n)?')
-_double_quote_escapes = _make_regex(r"\\[\\'\"abfnrtv]")
-_single_quote_escapes = _make_regex(r"\\[\\']")
-
-
-class Original(ta.NamedTuple):
+_dotenv_newline_pat = _make_dotenv_regex(r'(\r\n|\n|\r)')
+_dotenv_multiline_whitespace_pat = _make_dotenv_regex(r'\s*', extra_flags=re.MULTILINE)
+_dotenv_whitespace_pat = _make_dotenv_regex(r'[^\S\r\n]*')
+_dotenv_export_pat = _make_dotenv_regex(r'(?:export[^\S\r\n]+)?')
+_dotenv_single_quoted_key_pat = _make_dotenv_regex(r"'([^']+)'")
+_dotenv_unquoted_key_pat = _make_dotenv_regex(r'([^=\#\s]+)')
+_dotenv_equal_sign_pat = _make_dotenv_regex(r'(=[^\S\r\n]*)')
+_dotenv_single_quoted_value_pat = _make_dotenv_regex(r"'((?:\\'|[^'])*)'")
+_dotenv_double_quoted_value_pat = _make_dotenv_regex(r'"((?:\\"|[^"])*)"')
+_dotenv_unquoted_value_pat = _make_dotenv_regex(r'([^\r\n]*)')
+_dotenv_comment_pat = _make_dotenv_regex(r'(?:[^\S\r\n]*#[^\r\n]*)?')
+_dotenv_end_of_line_pat = _make_dotenv_regex(r'[^\S\r\n]*(?:\r\n|\n|\r|$)')
+_dotenv_rest_of_line_pat = _make_dotenv_regex(r'[^\r\n]*(?:\r|\n|\r\n)?')
+_dotenv_double_quote_escapes_pat = _make_dotenv_regex(r"\\[\\'\"abfnrtv]")
+_dotenv_single_quote_escapes_pat = _make_dotenv_regex(r"\\[\\']")
+
+
+class DotenvOriginal(ta.NamedTuple):
     string: str
     line: int
 
 
-class Binding(ta.NamedTuple):
-    key: str | None
-    value: str | None
-    original: Original
+class DotenvBinding(ta.NamedTuple):
+    key: ta.Optional[str]
+    value: ta.Optional[str]
+    original: DotenvOriginal
     error: bool
 
 
-class _Position:
+class _DotenvPosition:
     def __init__(self, chars: int, line: int) -> None:
         super().__init__()
         self.chars = chars
         self.line = line
 
     @classmethod
-    def start(cls) -> '_Position':
+    def start(cls) -> '_DotenvPosition':
         return cls(chars=0, line=1)
 
-    def set(self, other: '_Position') -> None:
+    def set(self, other: '_DotenvPosition') -> None:
         self.chars = other.chars
         self.line = other.line
 
     def advance(self, string: str) -> None:
         self.chars += len(string)
-        self.line += len(re.findall(_newline, string))
+        self.line += len(re.findall(_dotenv_newline_pat, string))
 
 
-class Error(Exception):
+class DotenvError(Exception):
     pass
 
 
-class _Reader:
+class _DotenvReader:
     def __init__(self, stream: ta.IO[str]) -> None:
         super().__init__()
         self.string = stream.read()
-        self.position = _Position.start()
-        self.mark = _Position.start()
+        self.position = _DotenvPosition.start()
+        self.mark = _DotenvPosition.start()
 
     def has_next(self) -> bool:
         return self.position.chars < len(self.string)
@@ -201,8 +197,8 @@ class _Reader:
     def set_mark(self) -> None:
         self.mark.set(self.position)
 
-    def get_marked(self) -> Original:
-        return Original(
+    def get_marked(self) -> DotenvOriginal:
+        return DotenvOriginal(
             string=self.string[self.mark.chars:self.position.chars],
             line=self.mark.line,
         )
@@ -213,85 +209,85 @@ class _Reader:
     def read(self, count: int) -> str:
         result = self.string[self.position.chars:self.position.chars + count]
         if len(result) < count:
-            raise Error('read: End of string')
+            raise DotenvError('read: End of string')
         self.position.advance(result)
         return result
 
     def read_regex(self, regex: ta.Pattern[str]) -> ta.Sequence[str]:
         match = regex.match(self.string, self.position.chars)
         if match is None:
-            raise Error('read_regex: Pattern not found')
+            raise DotenvError('read_regex: Pattern not found')
         self.position.advance(self.string[match.start():match.end()])
         return match.groups()
 
 
-def _decode_escapes(regex: ta.Pattern[str], string: str) -> str:
+def _decode_dotenv_escapes(regex: ta.Pattern[str], string: str) -> str:
     def decode_match(match: ta.Match[str]) -> str:
         return codecs.decode(match.group(0), 'unicode-escape')
 
     return regex.sub(decode_match, string)
 
 
-def _parse_key(reader: _Reader) -> str | None:
+def _parse_dotenv_key(reader: _DotenvReader) -> ta.Optional[str]:
     char = reader.peek(1)
     if char == '#':
         return None
     elif char == "'":
-        (key,) = reader.read_regex(_single_quoted_key)
+        (key,) = reader.read_regex(_dotenv_single_quoted_key_pat)
     else:
-        (key,) = reader.read_regex(_unquoted_key)
+        (key,) = reader.read_regex(_dotenv_unquoted_key_pat)
     return key
 
 
-def _parse_unquoted_value(reader: _Reader) -> str:
-    (part,) = reader.read_regex(_unquoted_value)
+def _parse_dotenv_unquoted_value(reader: _DotenvReader) -> str:
+    (part,) = reader.read_regex(_dotenv_unquoted_value_pat)
     return re.sub(r'\s+#.*', '', part).rstrip()
 
 
-def _parse_value(reader: _Reader) -> str:
+def _parse_dotenv_value(reader: _DotenvReader) -> str:
     char = reader.peek(1)
     if char == "'":
-        (value,) = reader.read_regex(_single_quoted_value)
-        return _decode_escapes(_single_quote_escapes, value)
+        (value,) = reader.read_regex(_dotenv_single_quoted_value_pat)
+        return _decode_dotenv_escapes(_dotenv_single_quote_escapes_pat, value)
     elif char == '"':
-        (value,) = reader.read_regex(_double_quoted_value)
-        return _decode_escapes(_double_quote_escapes, value)
+        (value,) = reader.read_regex(_dotenv_double_quoted_value_pat)
+        return _decode_dotenv_escapes(_dotenv_double_quote_escapes_pat, value)
     elif char in ('', '\n', '\r'):
         return ''
     else:
-        return _parse_unquoted_value(reader)
+        return _parse_dotenv_unquoted_value(reader)
 
 
-def _parse_binding(reader: _Reader) -> Binding:
+def _parse_dotenv_binding(reader: _DotenvReader) -> DotenvBinding:
     reader.set_mark()
     try:
-        reader.read_regex(_multiline_whitespace)
+        reader.read_regex(_dotenv_multiline_whitespace_pat)
         if not reader.has_next():
-            return Binding(
+            return DotenvBinding(
                 key=None,
                 value=None,
                 original=reader.get_marked(),
                 error=False,
             )
-        reader.read_regex(_export)
-        key = _parse_key(reader)
-        reader.read_regex(_whitespace)
+        reader.read_regex(_dotenv_export_pat)
+        key = _parse_dotenv_key(reader)
+        reader.read_regex(_dotenv_whitespace_pat)
         if reader.peek(1) == '=':
-            reader.read_regex(_equal_sign)
-            value: str | None = _parse_value(reader)
+            reader.read_regex(_dotenv_equal_sign_pat)
+            value: ta.Optional[str] = _parse_dotenv_value(reader)
         else:
             value = None
-        reader.read_regex(_comment)
-        reader.read_regex(_end_of_line)
-        return Binding(
+        reader.read_regex(_dotenv_comment_pat)
+        reader.read_regex(_dotenv_end_of_line_pat)
+        return DotenvBinding(
             key=key,
             value=value,
             original=reader.get_marked(),
             error=False,
         )
-    except Error:
-        reader.read_regex(_rest_of_line)
-        return Binding(
+    except DotenvError:
+        reader.read_regex(_dotenv_rest_of_line_pat)
+        return DotenvBinding(
             key=None,
             value=None,
             original=reader.get_marked(),
@@ -299,54 +295,54 @@ def _parse_binding(reader: _Reader) -> Binding:
         )
 
 
-def parse_stream(stream: ta.IO[str]) -> ta.Iterator[Binding]:
-    reader = _Reader(stream)
+def parse_dotenv_stream(stream: ta.IO[str]) -> ta.Iterator[DotenvBinding]:
+    reader = _DotenvReader(stream)
     while reader.has_next():
-        yield _parse_binding(reader)
+        yield _parse_dotenv_binding(reader)
 
 
 ##
 
 
-# A type alias for a string path to be used for the paths in this file. These paths may flow to `open()` and
-# `shutil.move()`; `shutil.move()` only accepts string paths, not byte paths or file descriptors. See
-# https://github.com/python/typeshed/pull/6832.
-StrPath: ta.TypeAlias = ta.Union[str, 'os.PathLike[str]']
-
-
-def _with_warn_for_invalid_lines(mappings: ta.Iterator[Binding]) -> ta.Iterator[Binding]:
+def _dotenv_with_warn_for_invalid_lines(
+        mappings: ta.Iterator[DotenvBinding],
+        log: ta.Optional[logging.Logger] = None,
+) -> ta.Iterator[DotenvBinding]:
     for mapping in mappings:
         if mapping.error:
-            log.warning(
-                'dotenv could not parse statement starting at line %s',
-                mapping.original.line,
-            )
+            if log is not None:
+                log.warning(
+                    'dotenv could not parse statement starting at line %s',
+                    mapping.original.line,
+                )
         yield mapping
 
 
-StrMutableMappingT = ta.TypeVar('StrMutableMappingT', bound=ta.MutableMapping[str, str])
+StrStrMutableMappingT = ta.TypeVar('StrStrMutableMappingT', bound=ta.MutableMapping[str, str])
 
 
-class DotEnv:
+class Dotenv:
     def __init__(
         self,
-        path: StrPath | None = None,
-        stream: ta.IO[str] | None = None,
+        path: ta.Union[str, 'os.PathLike[str]', None] = None,
+        stream: ta.Optional[ta.IO[str]] = None,
         verbose: bool = False,
-        encoding: str | None = None,
+        encoding: ta.Optional[str] = None,
         interpolate: bool = True,
         override: bool = True,
-        env: ta.Mapping[str, str] | None = None,
+        env: ta.Optional[ta.Mapping[str, str]] = None,
+        log: ta.Optional[logging.Logger] = None,
     ) -> None:
         super().__init__()
-        self.path: StrPath | None = path
-        self.stream: ta.IO[str] | None = stream
-        self._dict: dict[str, str | None] | None = None
+        self.path: ta.Union[str, 'os.PathLike[str]', None] = path
+        self.stream: ta.Optional[ta.IO[str]] = stream
+        self._dict: ta.Optional[ta.Dict[str, ta.Optional[str]]] = None
         self.verbose: bool = verbose
-        self.encoding: str | None = encoding
+        self.encoding: ta.Optional[str] = encoding
         self.interpolate: bool = interpolate
         self.override: bool = override
         self.env = env or {}
+        self.log = log
 
     @contextlib.contextmanager
     def _get_stream(self) -> ta.Iterator[ta.IO[str]]:
@@ -357,26 +353,27 @@ class DotEnv:
             yield self.stream
         else:
             if self.verbose:
-                log.info(
-                    'dotenv could not find configuration file %s.',
-                    self.path or '.env',
-                )
+                if self.log is not None:
+                    self.log.info(
+                        'dotenv could not find configuration file %s.',
+                        self.path or '.env',
+                    )
             yield io.StringIO('')
 
-    def dict(self) -> dict[str, str | None]:
+    def dict(self) -> ta.Dict[str, ta.Optional[str]]:
         if self._dict:
             return self._dict
 
         raw_values = self.parse()
 
         if self.interpolate:
-            self._dict = resolve_variables(raw_values, override=self.override, env=self.env)
+            self._dict = dotenv_resolve_variables(raw_values, override=self.override, env=self.env)
         else:
             self._dict = dict(raw_values)
 
         return self._dict
 
-    def apply_to(self, dst: StrMutableMappingT) -> StrMutableMappingT:
+    def apply_to(self, dst: StrStrMutableMappingT) -> StrStrMutableMappingT:
         for k, v in self.dict().items():
             if v is not None:
                 dst[k] = v
@@ -384,20 +381,21 @@ class DotEnv:
                 del dst[k]
         return dst
 
-    def parse(self) -> ta.Iterator[tuple[str, str | None]]:
+    def parse(self) -> ta.Iterator[ta.Tuple[str, ta.Optional[str]]]:
         with self._get_stream() as stream:
-            for mapping in _with_warn_for_invalid_lines(parse_stream(stream)):
+            for mapping in _dotenv_with_warn_for_invalid_lines(parse_dotenv_stream(stream), self.log):
                 if mapping.key is not None:
                     yield mapping.key, mapping.value
 
-    def get(self, key: str) -> str | None:
+    def get(self, key: str) -> ta.Optional[str]:
         data = self.dict()
 
         if key in data:
             return data[key]
 
         if self.verbose:
-            log.warning('Key %s not found in %s.', key, self.path)
+            if self.log is not None:
+                self.log.warning('Key %s not found in %s.', key, self.path)
 
         return None
 
@@ -405,25 +403,32 @@ class DotEnv:
 ##
 
 
-def get_key(
-    path: StrPath,
+def dotenv_get_key(
+    path: ta.Union[str, 'os.PathLike[str]'],
     key_to_get: str,
     *,
-    encoding: str | None = 'utf-8',
-) -> str | None:
+    encoding: ta.Optional[str] = 'utf-8',
+    log: ta.Optional[logging.Logger] = None,
+) -> ta.Optional[str]:
     """
     Get the value of a given key from the given .env.
 
     Returns `None` if the key isn't found or doesn't have a value.
     """
-    return DotEnv(path, verbose=True, encoding=encoding).get(key_to_get)
+
+    return Dotenv(
+        path,
+        verbose=True,
+        encoding=encoding,
+        log=log,
+    ).get(key_to_get)
 
 
 @contextlib.contextmanager
-def _rewrite(
-    path: StrPath,
-    encoding: str | None,
-) -> ta.Iterator[tuple[ta.IO[str], ta.IO[str]]]:
+def _dotenv_rewrite(
+    path: ta.Union[str, 'os.PathLike[str]'],
+    encoding: ta.Optional[str],
+) -> ta.Iterator[ta.Tuple[ta.IO[str], ta.IO[str]]]:
     pathlib.Path(path).touch()
 
     with tempfile.NamedTemporaryFile(mode='w', encoding=encoding, delete=False) as dest:
@@ -441,21 +446,23 @@ def _rewrite(
         raise error from None
 
 
-def set_key(
-    path: StrPath,
+def dotenv_set_key(
+    path: ta.Union[str, 'os.PathLike[str]'],
     key_to_set: str,
     value_to_set: str,
     *,
     quote_mode: str = 'always',
     export: bool = False,
-    encoding: str | None = 'utf-8',
-) -> tuple[bool | None, str, str]:
+    encoding: ta.Optional[str] = 'utf-8',
+    log: ta.Optional[logging.Logger] = None,
+) -> ta.Tuple[ta.Optional[bool], str, str]:
     """
     Adds or Updates a key/value to the given .env
 
     If the .env path given doesn't exist, fails instead of risking creating
     an orphan .env somewhere in the filesystem
     """
+
     if quote_mode not in ('always', 'auto', 'never'):
         raise ValueError(f'Unknown quote_mode: {quote_mode}')
 
@@ -473,10 +480,10 @@ def set_key(
     else:
         line_out = f'{key_to_set}={value_out}\n'
 
-    with _rewrite(path, encoding=encoding) as (source, dest):
+    with _dotenv_rewrite(path, encoding=encoding) as (source, dest):
         replaced = False
         missing_newline = False
-        for mapping in _with_warn_for_invalid_lines(parse_stream(source)):
+        for mapping in _dotenv_with_warn_for_invalid_lines(parse_dotenv_stream(source), log):
             if mapping.key == key_to_set:
                 dest.write(line_out)
                 replaced = True
@@ -491,51 +498,55 @@ def set_key(
     return True, key_to_set, value_to_set
 
 
-def unset_key(
-    path: StrPath,
+def dotenv_unset_key(
+    path: ta.Union[str, 'os.PathLike[str]'],
     key_to_unset: str,
     *,
     quote_mode: str = 'always',
-    encoding: str | None = 'utf-8',
-) -> tuple[bool | None, str]:
+    encoding: ta.Optional[str] = 'utf-8',
+    log: ta.Optional[logging.Logger] = None,
+) -> ta.Tuple[ta.Optional[bool], str]:
     """
     Removes a given key from the given `.env` file.
 
     If the .env path given doesn't exist, fails.
     If the given key doesn't exist in the .env, fails.
     """
+
     if not os.path.exists(path):
-        log.warning("Can't delete from %s - it doesn't exist.", path)
+        if log is not None:
+            log.warning("Can't delete from %s - it doesn't exist.", path)
         return None, key_to_unset
 
     removed = False
-    with _rewrite(path, encoding=encoding) as (source, dest):
-        for mapping in _with_warn_for_invalid_lines(parse_stream(source)):
+    with _dotenv_rewrite(path, encoding=encoding) as (source, dest):
+        for mapping in _dotenv_with_warn_for_invalid_lines(parse_dotenv_stream(source), log):
             if mapping.key == key_to_unset:
                 removed = True
             else:
                 dest.write(mapping.original.string)
 
     if not removed:
-        log.warning("Key %s not removed from %s - key doesn't exist.", key_to_unset, path)
+        if log is not None:
+            log.warning("Key %s not removed from %s - key doesn't exist.", key_to_unset, path)
         return None, key_to_unset
 
     return removed, key_to_unset
 
 
-def resolve_variables(
-        values: ta.Iterable[tuple[str, str | None]],
+def dotenv_resolve_variables(
+        values: ta.Iterable[ta.Tuple[str, ta.Optional[str]]],
         override: bool,
         env: ta.Mapping[str, str],
-) -> dict[str, str | None]:
-    new_values: dict[str, str | None] = {}
+) -> ta.Dict[str, ta.Optional[str]]:
+    new_values: ta.Dict[str, ta.Optional[str]] = {}
 
     for (name, value) in values:
         if value is None:
             result = None
         else:
-            atoms = parse_variables(value)
-            aenv: dict[str, str | None] = {}
+            atoms = parse_dotenv_variables(value)
+            aenv: ta.Dict[str, ta.Optional[str]] = {}
             if override:
                 aenv.update(env)
                 aenv.update(new_values)
@@ -550,14 +561,15 @@ def resolve_variables(
 
 
 def dotenv_values(
-    path: StrPath | None = None,
-    stream: ta.IO[str] | None = None,
+    path: ta.Union[str, 'os.PathLike[str]', None] = None,
+    stream: ta.Optional[ta.IO[str]] = None,
     *,
     verbose: bool = False,
     interpolate: bool = True,
-    encoding: str | None = 'utf-8',
-    env: ta.Mapping[str, str] | None = None,
-) -> dict[str, str | None]:
+    encoding: ta.Optional[str] = 'utf-8',
+    env: ta.Optional[ta.Mapping[str, str]] = None,
+    log: ta.Optional[logging.Logger] = None,
+) -> ta.Dict[str, ta.Optional[str]]:
     """
     Parse a .env file and return its content as a dict.
 
@@ -574,10 +586,11 @@ def dotenv_values(
     If both `path` and `stream` are `None`, `find_dotenv()` is used to find the
     .env file.
     """
+
     if path is None and stream is None:
         raise ValueError('must set path or stream')
 
-    return DotEnv(
+    return Dotenv(
         path=path,
         stream=stream,
         verbose=verbose,
@@ -585,4 +598,5 @@ def dotenv_values(
         override=True,
         encoding=encoding,
         env=env,
+        log=log,
     ).dict()

omlish/inject/__init__.py

@@ -106,7 +106,7 @@ from .scopes import (  # noqa
     ScopeSeededProvider,
     SeededScope,
     Singleton,
-    Thread,
+    ThreadScope,
     bind_scope,
     bind_scope_seed,
     enter_seeded_scope,

omlish/inject/impl/injector.py

@@ -33,7 +33,7 @@ from ..listeners import ProvisionListener
 from ..listeners import ProvisionListenerBinding
 from ..scopes import ScopeBinding
 from ..scopes import Singleton
-from ..scopes import Thread
+from ..scopes import ThreadScope
 from ..types import Scope
 from ..types import Unscoped
 from .elements import ElementCollection
@@ -48,7 +48,7 @@ log = logging.getLogger(__name__)
 DEFAULT_SCOPES: list[Scope] = [
     Unscoped(),
     Singleton(),
-    Thread(),
+    ThreadScope(),
 ]
 
 

omlish/inject/impl/scopes.py

@@ -24,7 +24,7 @@ from ..providers import Provider
 from ..scopes import ScopeSeededProvider
 from ..scopes import SeededScope
 from ..scopes import Singleton
-from ..scopes import Thread
+from ..scopes import ThreadScope
 from ..types import Scope
 from ..types import Unscoped
 from .bindings import BindingImpl
@@ -86,8 +86,8 @@ class ThreadScopeImpl(ScopeImpl, lang.Final):
         self._local = threading.local()
 
     @property
-    def scope(self) -> Thread:
-        return Thread()
+    def scope(self) -> ThreadScope:
+        return ThreadScope()
 
     def provide(self, binding: BindingImpl, injector: Injector) -> ta.Any:
         dct: dict[BindingImpl, ta.Any]
@@ -190,7 +190,7 @@ class SeededScopeImpl(ScopeImpl):
 SCOPE_IMPLS_BY_SCOPE: dict[type[Scope], ta.Callable[..., ScopeImpl]] = {
     Unscoped: lambda _: UnscopedScopeImpl(),
     Singleton: lambda _: SingletonScopeImpl(),
-    Thread: lambda _: ThreadScopeImpl(),
+    ThreadScope: lambda _: ThreadScopeImpl(),
     SeededScope: lambda s: SeededScopeImpl(s),
 }
 

omlish/inject/scopes.py

@@ -49,11 +49,11 @@ SCOPE_ALIASES['singleton'] = Singleton()
 ##
 
 
-class Thread(Scope, lang.Singleton, lang.Final):
+class ThreadScope(Scope, lang.Singleton, lang.Final):
     pass
 
 
-SCOPE_ALIASES['thread'] = Thread()
+SCOPE_ALIASES['thread'] = ThreadScope()
 
 
 ##

{omlish-0.0.0.dev130.dist-info → omlish-0.0.0.dev131.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev130
+Version: 0.0.0.dev131
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -39,7 +39,7 @@ Requires-Dist: pymysql~=1.1; extra == "all"
 Requires-Dist: aiomysql~=0.2; extra == "all"
 Requires-Dist: aiosqlite~=0.20; extra == "all"
 Requires-Dist: asyncpg~=0.30; extra == "all"
-Requires-Dist: apsw~=3.46; extra == "all"
+Requires-Dist: apsw~=3.47; extra == "all"
 Requires-Dist: sqlean.py~=3.45; extra == "all"
 Requires-Dist: duckdb~=1.1; extra == "all"
 Requires-Dist: pytest~=8.0; extra == "all"
@@ -85,7 +85,7 @@ Requires-Dist: pymysql~=1.1; extra == "sqldrivers"
 Requires-Dist: aiomysql~=0.2; extra == "sqldrivers"
 Requires-Dist: aiosqlite~=0.20; extra == "sqldrivers"
 Requires-Dist: asyncpg~=0.30; extra == "sqldrivers"
-Requires-Dist: apsw~=3.46; extra == "sqldrivers"
+Requires-Dist: apsw~=3.47; extra == "sqldrivers"
 Requires-Dist: sqlean.py~=3.45; extra == "sqldrivers"
 Requires-Dist: duckdb~=1.1; extra == "sqldrivers"
 Provides-Extra: testing

{omlish-0.0.0.dev130.dist-info → omlish-0.0.0.dev131.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=CxGnj-UiRPlZgmgWoovDWrOnqpSEmBy_kqA7cdfSA3w,1431
-omlish/__about__.py,sha256=PvbOOiIxO1ksGKnYclis2IJG4h8EtRZ-Qy1gtTkvgI4,3379
+omlish/__about__.py,sha256=d7BMVkW2N3aBZ6Tdsm0Fd2b0CcKLA6TPpoZPJHMAGDM,3379
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/argparse.py,sha256=cqKGAqcxuxv_s62z0gq29L9KAvg_3-_rFvXKjVpRJjo,8126
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
@@ -178,7 +178,7 @@ omlish/docker/helpers.py,sha256=9uyHpPVbsB2jqTzvU7jiLzTkDN1omqofse1w4B4GH5E,612
 omlish/docker/hub.py,sha256=7LIuJGdA-N1Y1dmo50ynKM1KUTcnQM_5XbtPbdT_QLU,3940
 omlish/docker/manifests.py,sha256=LR4FpOGNUT3bZQ-gTjB6r_-1C3YiG30QvevZjrsVUQM,7068
 omlish/formats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/formats/dotenv.py,sha256=orf37G11RM6Z6MxjBWbFAntwT8fi-ptkjN4EWoTeAsA,17689
+omlish/formats/dotenv.py,sha256=qoDG4Ayu7B-8LjBBhcmNiLZW0_9LgCi3Ri2aPo9DEQ8,19314
 omlish/formats/props.py,sha256=cek3JLFLIrpE76gvs8rs_B8yF4SpY8ooDH8apWsquwE,18953
 omlish/formats/xml.py,sha256=ggiOwSERt4d9XmZwLZiDIh5qnFJS4jdmow9m9_9USps,1491
 omlish/formats/yaml.py,sha256=wTW8ECG9jyA7qIFUqKZUro4KAKpN4IvcW_qhlrKveXM,6836
@@ -232,7 +232,7 @@ omlish/http/multipart.py,sha256=R9ycpHsXRcmh0uoc43aYb7BdWL-8kSQHe7J-M81aQZM,2240
 omlish/http/sessions.py,sha256=VZ_WS5uiQG5y7i3u8oKuQMqf8dPKUOjFm_qk_0OvI8c,4793
 omlish/http/sse.py,sha256=MDs9RvxQXoQliImcc6qK1ERajEYM7Q1l8xmr-9ceNBc,2315
 omlish/http/wsgi.py,sha256=czZsVUX-l2YTlMrUjKN49wRoP4rVpS0qpeBn4O5BoMY,948
-omlish/inject/__init__.py,sha256=JQ7x8l9MjU-kJ5ap7cPVq7SY7zbbCIrjyJAF0UeE5-s,1886
+omlish/inject/__init__.py,sha256=n0RC9UDGsBQQ39cST39-XJqJPq2M0tnnh9yJubW9azo,1891
 omlish/inject/binder.py,sha256=DAbc8TZi5w8Mna0TUtq0mT4jeDVA7i7SlBtOFrh2swc,4185
 omlish/inject/bindings.py,sha256=pLXn2U3kvmAS-68IOG-tr77DbiI-wp9hGyy4lhG6_H8,525
 omlish/inject/eagers.py,sha256=5AkGYuwijG0ihsH9NSaZotggalJ5_xWXhHE9mkn6IBA,329
@@ -248,20 +248,20 @@ omlish/inject/origins.py,sha256=OVQkiuRxx6ZtE8ZliufdndtFexcfpj-wZSDkUeGUCYM,534
 omlish/inject/overrides.py,sha256=hrm243slCw_DDRbn3dK5QK1jfHezVokG-WYO2JaQOV8,535
 omlish/inject/privates.py,sha256=hZOa_keY3KlXAzyiZ-sfN697UKXpkfXXNUIEmGT5TAA,641
 omlish/inject/providers.py,sha256=Z6UzNCwRhKHHR0L5CyBMo4F-1M_xElLkPA6EKQWcqlw,754
-omlish/inject/scopes.py,sha256=0b8Y0VidkpEk7tyxKSbv_1fE-2LomKTYlhFeoEemkwg,1979
+omlish/inject/scopes.py,sha256=bxbpEPqRs9N61GDKD-4ZWXkB6xiLDrILLjcE2IvZEtM,1989
 omlish/inject/types.py,sha256=11WVEPkZ-_8cv1BeTDRU-soIYxB_6x7dyWtsa2Iej9U,251
 omlish/inject/utils.py,sha256=_UOZqA8IcLWPqf4Mcg9iIusQ5yxP_6Txg6PWtUYl23o,408
 omlish/inject/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/inject/impl/bindings.py,sha256=8H586RCgmvwq53XBL9WMbb-1-Tdw_hh9zxIDCwcHA1c,414
 omlish/inject/impl/elements.py,sha256=bJBbHce_eZyIua2wbcejMwd9Uv-QeYcQ-c5N1qOXSmU,5950
-omlish/inject/impl/injector.py,sha256=WxIVOF6zvipb44302_j-xQZt8vnNCY0gdLX6UWzslXI,7550
+omlish/inject/impl/injector.py,sha256=8Pm2TbI-ySfibpHG2kFeF1nBHkh5v-NEynykljkQ8ew,7560
 omlish/inject/impl/inspect.py,sha256=J0d2HJ-Z2-cHD4mJ0Kf5oJCOa2bMVG68Oh0Mhe3Cay4,3120
 omlish/inject/impl/multis.py,sha256=rRIWNCiTGaSWQUz_jxEy8LUmzdJDAlG94sLHYDS-ncg,2048
 omlish/inject/impl/origins.py,sha256=-cdcwz3BWb5LuC9Yn5ynYOwyPsKH06-kCc-3U0PxZ5w,1640
 omlish/inject/impl/privates.py,sha256=alpCYyk5VJ9lJknbRH2nLVNFYVvFhkj-VC1Vco3zCFQ,2613
 omlish/inject/impl/providers.py,sha256=QnwhsujJFIHC0JTgd2Wlo1kP53i3CWTrj1nKU2DNxwg,2375
 omlish/inject/impl/proxy.py,sha256=1ko0VaKqzu9UG8bIldp9xtUrAVUOFTKWKTjOCqIGr4s,1636
-omlish/inject/impl/scopes.py,sha256=ASfULXgP_ETlsAqFJfrZmyEaZt64Zr8tNn5ScA-EoXk,5900
+omlish/inject/impl/scopes.py,sha256=hKnzNieB-fJSFEXDP_QG1mCfIKoVFIfFlf9LiIt5tk4,5920
 omlish/io/__init__.py,sha256=aaIEsXTSfytW-oEkUWczdUJ_ifFY7ihIpyidIbfjkwY,56
 omlish/io/_abc.py,sha256=Cxs8KB1B_69rxpUYxI-MTsilAmNooJJn3w07DKqYKkE,1255
 omlish/io/pyio.py,sha256=YB3g6yg64MzcFwbzKBo4adnbsbZ3FZMlOZfjNtWmYoc,95316
@@ -488,9 +488,9 @@ omlish/text/glyphsplit.py,sha256=Ug-dPRO7x-OrNNr8g1y6DotSZ2KH0S-VcOmUobwa4B0,329
 omlish/text/indent.py,sha256=6Jj6TFY9unaPa4xPzrnZemJ-fHsV53IamP93XGjSUHs,1274
 omlish/text/parts.py,sha256=7vPF1aTZdvLVYJ4EwBZVzRSy8XB3YqPd7JwEnNGGAOo,6495
 omlish/text/random.py,sha256=jNWpqiaKjKyTdMXC-pWAsSC10AAP-cmRRPVhm59ZWLk,194
-omlish-0.0.0.dev130.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev130.dist-info/METADATA,sha256=1UOC8pu3kIMCWi1vb1n83h4VZjHWkmZpcmwpEzxERlk,4173
-omlish-0.0.0.dev130.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-omlish-0.0.0.dev130.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev130.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev130.dist-info/RECORD,,
+omlish-0.0.0.dev131.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev131.dist-info/METADATA,sha256=V7J6J12IhBiLRFrCaAkvQgvB1VPvsZSzu32VsYQGSdE,4173
+omlish-0.0.0.dev131.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+omlish-0.0.0.dev131.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev131.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev131.dist-info/RECORD,,