omdev 0.0.0.dev486__py3-none-any.whl → 0.0.0.dev495__py3-none-any.whl

omdev/.omlish-manifests.json

@@ -39,7 +39,7 @@
     "module": ".cli.clicli",
     "attr": "_CLI_MODULE",
     "file": "omdev/cli/clicli.py",
-    "line": 233,
+    "line": 263,
     "value": {
       "!.cli.types.CliModule": {
         "name": "cli",

omdev/README.md

@@ -0,0 +1,51 @@
+# Overview
+
+Development utilities and support code.
+
+# Notable packages
+
+- **[cli](https://github.com/wrmsr/omlish/blob/master/omdev/cli)** - The codebase's all-in-one CLI. This is not
+  installed as an entrypoint / command when this package is itself installed - that is separated into the `omdev-cli`
+  installable package so as to not pollute users' bin/ directories when depping this lib for its utility code.
+
+- **[amalg](https://github.com/wrmsr/omlish/blob/master/omdev/amalg)** - The [amalgamator](#amalgamation).
+
+- **[pyproject](https://github.com/wrmsr/omlish/blob/master/omdev/pyproject)**
+  ([amalg](https://github.com/wrmsr/omlish/blob/master/omdev/scripts/pyproject.py)) - python project management tool.
+  wrangles but does not replace tools like venv, pip, setuptools, and uv. does things like sets up venvs, generates
+  [`.pkg`](https://github.com/wrmsr/omlish/blob/master/.pkg) directories and their `pyproject.toml`'s (from their
+  `__about__.py`'s), and packages them. this should grow to eat more and more of the Makefile. as it is amalgamated it
+  requires no installation and can just be dropped into other projects / repos.
+
+- **[ci](https://github.com/wrmsr/omlish/blob/master/omdev/ci)**
+  ([amalg](https://github.com/wrmsr/omlish/blob/master/omdev/scripts/ci.py)) - ci runner. given a
+  [`compose.yml`](https://github.com/wrmsr/omlish/blob/master/docker/compose.yml)
+  and requirements.txt files, takes care of building and caching of containers and venvs and execution of required ci
+  commands. detects and [natively uses](https://github.com/wrmsr/omlish/blob/master/omdev/ci/github/api/v2)
+  github-action's caching system. unifies ci execution between local dev and github runners.
+
+- **[tools.json](https://github.com/wrmsr/omlish/blob/master/omdev/tools/json)** (cli: `om j`) - a tool for json-like
+  data, obviously in the vein of [jq](https://github.com/jqlang/jq) but using the internal
+  [jmespath](https://github.com/wrmsr/omlish/blob/master/omlish/specs/jmespath) engine. supports
+  [true streaming](https://github.com/wrmsr/omlish/blob/master/omlish/formats/json/stream) json input and output, as
+  well as [various other](https://github.com/wrmsr/omlish/blob/master/omdev/tools/json/formats.py) non-streaming input
+  formats.
+
+- **[tools.git](https://github.com/wrmsr/omlish/blob/master/omdev/tools/git)** (cli: `om git`) - a tool for various lazy
+  git operations, including the one that (poorly) writes all of these commit messages.
+
+# Amalgamation
+
+Amalgamation is the process of stitching together multiple python source files into a single self-contained python
+script. ['lite'](https://github.com/wrmsr/omlish/blob/master/omlish#lite-code) code is written in a style conducive to
+this.
+
+# Local storage
+
+Some of this code, when asked, will store things on the local filesystem. The only directories used (outside of ones
+explicitly specified as command or function arguments) are managed in
+[home.paths](https://github.com/wrmsr/omlish/blob/master/omdev/home/paths.py), and are the following:
+
+- `$OMLISH_HOME`, default of `~/.omlish` - persistent things like config and state.
+- `$OMLISH_CACHE`, default of `~/.cache/omlish` - used for things like the local ci cache and
+  [various other](https://github.com/search?q=repo%3Awrmsr%2Fomlish+%22dcache.%22&type=code) cached data.

omdev/__about__.py

@@ -13,7 +13,7 @@ class Project(ProjectBase):
 
     optional_dependencies = {
         'black': [
-            'black ~= 25.11',
+            'black ~= 25.12',
         ],
 
         'c': [
@@ -44,7 +44,9 @@ class Project(ProjectBase):
 
         'tui': [
             'rich ~= 14.2',
-            'textual ~= 6.8',
+            'textual ~= 6.11',  # [syntax]
+            'textual-dev ~= 1.8',
+            'textual-speedups ~= 0.2',
         ],
     }
 

omdev/ci/cli.py

@@ -22,7 +22,7 @@ from omlish.argparse.cli import argparse_cmd
 from omlish.lite.check import check
 from omlish.lite.inject import inj
 from omlish.logs.modules import get_module_logger
-from omlish.logs.standard import configure_standard_logging
+from omlish.logs.std.standard import configure_standard_logging
 
 from .cache import DirectoryFileCache
 from .ci import Ci

omdev/cli/clicli.py

@@ -1,9 +1,11 @@
+import dataclasses as dc
 import inspect
 import os
 import re
 import shlex
 import subprocess
 import sys
+import time
 import typing as ta
 import urllib.parse
 import urllib.request
@@ -13,6 +15,7 @@ from omlish import lang
 from omlish.argparse import all as ap
 from omlish.os.temp import temp_dir_context
 
+from ..packaging.versions import Version
 from ..pip import get_root_dists
 from ..pip import lookup_latest_package_version
 from . import install
@@ -87,22 +90,49 @@ class CliCli(ap.Cli):
 
     #
 
+    @dc.dataclass()
+    class ReinstallWouldNotUpgradeError(Exception):
+        current_version: str
+        target_version: str
+
+        def __str__(self) -> str:
+            return f'Current version {self.current_version} is not older than target version {self.target_version} '
+
     @ap.cmd(
         ap.arg('--url', default=DEFAULT_REINSTALL_URL),
         ap.arg('--local', action='store_true'),
         ap.arg('--no-deps', action='store_true'),
         ap.arg('--no-uv', action='store_true'),
         ap.arg('--dry-run', action='store_true'),
+        ap.arg('--must-upgrade', action='store_true'),
+        ap.arg('--must-upgrade-loop', action='store_true'),
         ap.arg('--version'),
         ap.arg('extra_deps', nargs='*'),
     )
     def reinstall(self) -> None:
-        latest_version = _parse_latest_version_str(lookup_latest_package_version(__package__.split('.')[0]))
-
-        if self.args.version is not None:
-            target_version: str = self.args.version
-        else:
-            target_version = latest_version
+        current_version = __about__.__version__
+
+        while True:
+            latest_version = _parse_latest_version_str(lookup_latest_package_version(__package__.split('.')[0]))
+
+            if self.args.version is not None:
+                target_version: str = self.args.version
+            else:
+                target_version = latest_version
+
+            if self.args.must_upgrade or self.args.must_upgrade_loop:
+                current_vo = Version(current_version)
+                target_vo = Version(target_version)
+                if not (target_vo > current_vo):
+                    ex = CliCli.ReinstallWouldNotUpgradeError(current_version, target_version)
+                    if self.args.must_upgrade_loop:
+                        print(ex)
+                        time.sleep(1)
+                        continue
+                    else:
+                        raise ex
+
+            break
 
         #
 
@@ -186,7 +216,7 @@ class CliCli(ap.Cli):
 
         #
 
-        print(f'Current version: {__about__.__version__}')
+        print(f'Current version: {current_version}')
         print(f'Latest version: {latest_version}')
         print(f'Target version: {target_version}')
         print()

omdev/dataclasses/cli.py

@@ -1,5 +1,5 @@
 from omlish.argparse import all as ap
-from omlish.logs.standard import configure_standard_logging
+from omlish.logs.std.standard import configure_standard_logging
 
 from .codegen import DataclassCodeGen
 

omdev/interp/cli.py

@@ -17,7 +17,7 @@ from omlish.lite.check import check
 from omlish.lite.inject import Injector
 from omlish.lite.inject import inj
 from omlish.lite.runtime import check_lite_runtime_version
-from omlish.logs.standard import configure_standard_logging
+from omlish.logs.std.standard import configure_standard_logging
 
 from .inject import bind_interp
 from .resolvers import InterpResolver

omdev/interp/types.py

@@ -85,9 +85,10 @@ class InterpSpecifier:
     def parse(cls, s: str) -> 'InterpSpecifier':
         s, o = InterpOpts.parse_suffix(s)
         if not any(s.startswith(o) for o in Specifier.OPERATORS):
-            s = '~=' + s
             if s.count('.') < 2:
-                s += '.0'
+                s = '~=' + s + '.0'
+            else:
+                s = '==' + s
         return cls(
             specifier=Specifier(s),
             opts=o,

omdev/interp/uv/provider.py

@@ -5,7 +5,9 @@ uv run --python 3.11.6 pip
 uv venv --python 3.11.6 --seed barf
 python3 -m venv barf && barf/bin/pip install uv && barf/bin/uv venv --python 3.11.6 --seed barf2
 uv python find '3.13.10'
+uv python list --output-format=json
 """
+import dataclasses as dc
 import typing as ta
 
 from omlish.logs.protocols import LoggerLike
@@ -21,6 +23,34 @@ from .uv import Uv
 ##
 
 
+@dc.dataclass(frozen=True)
+class UvPythonListOutput:
+    key: str
+    version: str
+
+    @dc.dataclass(frozen=True)
+    class VersionParts:
+        major: int
+        minor: int
+        patch: int
+
+    version_parts: VersionParts
+
+    path: ta.Optional[str]
+    symlink: ta.Optional[str]
+
+    url: str
+
+    os: str  # emscripten linux macos
+    variant: str  # default freethreaded
+    implementation: str  # cpython graalpy pyodide pypy
+    arch: str  # aarch64 wasm32 x86_64
+    libc: str  # gnu musl none
+
+
+##
+
+
 class UvInterpProvider(InterpProvider):
     def __init__(
             self,
@@ -40,3 +70,9 @@ class UvInterpProvider(InterpProvider):
 
     async def get_installed_version(self, version: InterpVersion) -> Interp:
         raise NotImplementedError
+
+    # async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+    #     return []
+
+    # async def install_version(self, version: InterpVersion) -> Interp:
+    #     raise TypeError

omdev/manifests/main.py

@@ -5,7 +5,7 @@ import multiprocessing as mp
 import os.path
 
 from omlish.lite.json import json_dumps_pretty
-from omlish.logs.standard import configure_standard_logging
+from omlish.logs.std.standard import configure_standard_logging
 
 from .building import ManifestBuilder
 from .building import check_package_manifests

omdev/packaging/revisions.py

@@ -15,7 +15,7 @@ import zipfile
 from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check
 from omlish.logs.modules import get_module_logger
-from omlish.logs.standard import configure_standard_logging
+from omlish.logs.std.standard import configure_standard_logging
 
 from ..git.revisions import get_git_revision
 from .wheelfile import WheelFile

omdev/py/tools/pipdepup.py

@@ -1,6 +1,9 @@
 """
 TODO:
+ - output 2 tables lol
  - min_time_since_prev_version
+  - without this the min age is moot lol, can still catch a bad release at the same time of day just n days later
+   - * at least show 'suggested', 'suggested age', 'latest', 'latest age', 'number of releases between the 2' *
   - how to handle non-linearity? new minor vers come out in parallel for diff major vers
    - trie?
  - find which reqs file + lineno to update
@@ -28,7 +31,7 @@ https://news.ycombinator.com/item?id=46005111
 # ~> https://github.com/pypa/pip/blob/a52069365063ea813fe3a3f8bac90397c9426d35/src/pip/_internal/commands/list.py (25.3)
 import dataclasses as dc
 import datetime
-import email.parser
+import itertools
 import os.path
 import ssl
 import typing as ta
@@ -310,16 +313,42 @@ class Package:
 
             return datetime.datetime.fromisoformat(check.isinstance(ut, str))  # noqa
 
+        @cached.property
+        def version(self) -> Version:
+            return self.install.version
+
+        @cached.property
+        def filetype(self) -> ta.Literal['wheel', 'sdist']:
+            if self.install.link.is_wheel:
+                return 'wheel'
+            else:
+                return 'sdist'
+
+    unfiltered_candidates: ta.Sequence[Candidate] | None = None
     candidates: ta.Sequence[Candidate] | None = None
 
-    @dc.dataclass(frozen=True, kw_only=True)
-    class LatestInfo:
-        candidate: 'Package.Candidate'
+    latest_candidate: Candidate | None = None
+    suggested_candidate: Candidate | None = None
+
+
+def get_best_candidate(
+        pkg: Package,
+        finder: MyPackageFinder,
+        candidates: ta.Sequence[Package.Candidate],
+) -> Package.Candidate | None:
+    candidates_by_install: ta.Mapping[InstallationCandidate, Package.Candidate] = col.make_map((
+        (c.install, c)
+        for c in candidates
+    ), strict=True, identity=True)
 
-        version: Version
-        filetype: str
+    evaluator = finder.make_candidate_evaluator(
+        project_name=pkg.dist.canonical_name,
+    )
+    best_install = evaluator.sort_best_candidate([c.install for c in candidates])
+    if best_install is None:
+        return None
 
-    latest_info: LatestInfo | None = None
+    return candidates_by_install[best_install]
 
 
 def set_package_finder_info(
@@ -330,17 +359,18 @@ def set_package_finder_info(
         max_uploaded_at: datetime.datetime | None = None,
         min_time_since_prev_version: datetime.timedelta | None = None,
 ) -> None:
-    candidates = [
+    pkg.unfiltered_candidates = [
         Package.Candidate(
             c,
             finder.get_link_pypi_dict(c.link),
         )
         for c in finder.find_all_candidates(pkg.dist.canonical_name)
     ]
-    pkg.candidates = candidates
 
     #
 
+    candidates = pkg.unfiltered_candidates
+
     if not pre:
         # Remove prereleases
         candidates = [
@@ -349,8 +379,16 @@ def set_package_finder_info(
             if not c.install.version.is_prerelease
         ]
 
+    pkg.candidates = candidates
+
     #
 
+    pkg.latest_candidate = get_best_candidate(pkg, finder, pkg.candidates)
+
+    #
+
+    suggested_candidates = candidates
+
     if min_time_since_prev_version is not None:
         # candidates_by_version = col.multi_map((c.install.version, c) for c in candidates)
         # uploaded_at_by_version = {
@@ -359,46 +397,17 @@ def set_package_finder_info(
         # }
         raise NotImplementedError
 
-    #
-
     if max_uploaded_at is not None:
-        candidates = [
+        suggested_candidates = [
             c
-            for c in candidates
+            for c in suggested_candidates
             if not (
                 (c_dt := c.upload_time()) is not None and
                 c_dt > max_uploaded_at
             )
         ]
 
-    #
-
-    candidates_by_install: ta.Mapping[InstallationCandidate, Package.Candidate] = col.make_map((
-        (c.install, c)
-        for c in candidates
-    ), strict=True, identity=True)
-
-    evaluator = finder.make_candidate_evaluator(
-        project_name=pkg.dist.canonical_name,
-    )
-    best_install = evaluator.sort_best_candidate([c.install for c in candidates])
-    if best_install is None:
-        return
-    best_candidate = candidates_by_install[best_install]
-
-    #
-
-    remote_version = best_candidate.install.version
-    if best_candidate.install.link.is_wheel:
-        typ = 'wheel'
-    else:
-        typ = 'sdist'
-
-    pkg.latest_info = Package.LatestInfo(
-        candidate=best_candidate,
-        version=remote_version,
-        filetype=typ,
-    )
+    pkg.suggested_candidate = get_best_candidate(pkg, finder, suggested_candidates)
 
 
 ##
@@ -472,20 +481,20 @@ def format_for_json(
     infos: list[dict[str, ta.Any]] = []
 
     for pkg in pkgs:
-        latest_info = check.not_none(pkg.latest_info)
+        latest = check.not_none(pkg.latest_candidate)
+        suggested = check.not_none(pkg.suggested_candidate)
 
         info = {
             'name': pkg.dist.raw_name,
             'version': pkg.version(),
             'location': pkg.dist.location or '',
             'installer': pkg.dist.installer,
-            'latest_version': str(latest_info.version),
-            'latest_filetype': latest_info.filetype,
+            'latest_version': str(latest.install.version),
+            'latest_upload_time': lut.isoformat() if (lut := latest.upload_time()) is not None else None,
+            'suggested_version': str(suggested.install.version),
+            'suggested_upload_time': sut.isoformat() if (sut := suggested.upload_time()) is not None else None,
         }
 
-        if (l_ut := latest_info.candidate.upload_time()) is not None:
-            info['latest_age'] = human_round_td(now_utc() - l_ut)
-
         if editable_project_location := pkg.dist.editable_project_location:
             info['editable_project_location'] = editable_project_location
 
@@ -500,46 +509,87 @@ def format_for_json(
 def format_for_columns(pkgs: ta.Sequence[Package]) -> tuple[list[list[str]], list[str]]:
     """Convert the package data into something usable by output_package_listing_columns."""
 
-    header = ['Package', 'Version', 'Latest', 'Age', 'Type']
+    header = [
+        'Package',
+        'Current',
 
-    def wheel_build_tag(dist: BaseDistribution) -> str | None:
-        try:
-            wheel_file = dist.read_text('WHEEL')
-        except FileNotFoundError:
-            return None
-        return email.parser.Parser().parsestr(wheel_file).get('Build')
-
-    build_tags = [wheel_build_tag(p.dist) for p in pkgs]
-    has_build_tags = any(build_tags)
-    if has_build_tags:
-        header.append('Build')
-
-    has_editables = any(x.dist.editable for x in pkgs)
-    if has_editables:
-        header.append('Editable project location')
-
-    data = []
-    for i, proj in enumerate(pkgs):
-        # if we're working on the 'outdated' list, separate out the latest_version and type
-        row = [proj.dist.raw_name, proj.dist.raw_version]
-
-        latest_info = check.not_none(proj.latest_info)
-        row.append(str(latest_info.version))
-        if (l_ut := latest_info.candidate.upload_time()) is not None:
-            row.append(human_round_td(now_utc() - l_ut))
-        else:
-            row.append('')
-        row.append(latest_info.filetype)
+        'Suggested',
+        'Age',
 
-        if has_build_tags:
-            row.append(build_tags[i] or '')
+        'Latest',
+        'Age',
+    ]
 
-        if has_editables:
-            row.append(proj.dist.editable_project_location or '')
+    # def wheel_build_tag(dist: BaseDistribution) -> str | None:
+    #     try:
+    #         wheel_file = dist.read_text('WHEEL')
+    #     except FileNotFoundError:
+    #         return None
+    #     return email.parser.Parser().parsestr(wheel_file).get('Build')
 
-        data.append(row)
+    # build_tags = [wheel_build_tag(p.dist) for p in pkgs]
+    # has_build_tags = any(build_tags)
+    # if has_build_tags:
+    #     header.append('Build')
 
-    return data, header
+    # has_editables = any(x.dist.editable for x in pkgs)
+    # if has_editables:
+    #     header.append('Editable project location')
+
+    rows = []
+    for pkg in pkgs:
+        sc = check.not_none(pkg.suggested_candidate)
+        lc = check.not_none(pkg.latest_candidate)
+
+        row = [
+            pkg.dist.raw_name,
+            pkg.dist.raw_version,
+        ]
+
+        def add_c(c):
+            if c is None:
+                row.extend(['', ''])
+                return
+
+            row.append(str(c.version))
+
+            if (l_ut := c.upload_time()) is not None:
+                row.append(human_round_td(now_utc() - l_ut))
+            else:
+                row.append('')
+
+        add_c(sc if sc.version != pkg.dist.version else None)
+        add_c(lc if sc is not lc else None)
+
+        # if has_build_tags:
+        #     row.append(build_tags[i] or '')
+
+        # if has_editables:
+        #     row.append(pkg.dist.editable_project_location or '')
+
+        rows.append(row)
+
+    return rows, header
+
+
+def _tabulate(
+        rows: ta.Iterable[ta.Iterable[ta.Any]],
+        *,
+        sep: str = ' ',
+) -> tuple[list[str], list[int]]:
+    """
+    Return a list of formatted rows and a list of column sizes.
+
+    For example::
+
+    >>> tabulate([['foobar', 2000], [0xdeadbeef]])
+    (['foobar     2000', '3735928559'], [10, 4])
+    """
+
+    rows = [tuple(map(str, row)) for row in rows]
+    sizes = [max(map(len, col)) for col in itertools.zip_longest(*rows, fillvalue='')]
+    table = [sep.join(map(str.ljust, row, sizes)).rstrip() for row in rows]
+    return table, sizes
 
 
 def render_package_listing_columns(data: list[list[str]], header: list[str]) -> list[str]:
@@ -547,12 +597,11 @@ def render_package_listing_columns(data: list[list[str]], header: list[str]) ->
     if len(data) > 0:
         data.insert(0, header)
 
-    from pip._internal.utils.misc import tabulate  # noqa
-    pkg_strings, sizes = tabulate(data)
+    pkg_strings, sizes = _tabulate(data, sep='  ')
 
     # Create and add a separator.
     if len(data) > 0:
-        pkg_strings.insert(1, ' '.join('-' * x for x in sizes))
+        pkg_strings.insert(1, '  '.join('-' * x for x in sizes))
 
     return pkg_strings
 
@@ -565,12 +614,14 @@ def _main() -> None:
 
     parser = argparse.ArgumentParser()
     parser.add_argument('--exclude', action='append', dest='excludes')
-    parser.add_argument('--min-age-h', type=float, default=4 * 24)
-    parser.add_argument('-P', '--parallelism', type=int, default=4)
+    parser.add_argument('--min-age-h', type=float, default=24)
+    parser.add_argument('-P', '--parallelism', type=int, default=3)
     parser.add_argument('--json', action='store_true')
     args = parser.parse_args()
 
-    max_uploaded_at: datetime.datetime | None = now_utc() - datetime.timedelta(hours=args.min_age_h)
+    max_uploaded_at: datetime.datetime | None = None
+    if args.min_age_h is not None:
+        max_uploaded_at = now_utc() - datetime.timedelta(hours=args.min_age_h)
     min_time_since_prev_version: datetime.timedelta | None = None  # datetime.timedelta(days=1)
 
     #
@@ -608,21 +659,27 @@ def _main() -> None:
 
     #
 
-    pkgs = [
+    outdated_pkgs = [
         pkg
         for pkg in pkgs
-        if (li := pkg.latest_info) is not None
+        if (li := pkg.latest_candidate) is not None
         and li.version > pkg.dist.version
     ]
 
-    pkgs.sort(key=lambda x: x.dist.raw_name)
+    outdated_pkgs.sort(key=lambda x: x.dist.raw_name)
 
     #
 
     if args.json:
-        print(json.dumps_pretty(format_for_json(pkgs)))
+        print(json.dumps_pretty(format_for_json(outdated_pkgs)))
+
     else:
-        print('\n'.join(render_package_listing_columns(*format_for_columns(pkgs))))
+        # stable_pkgs, unstable_pkgs = col.partition(
+        #     outdated_pkgs,
+        #     lambda pkg: pkg.latest_candidate is pkg.suggested_candidate,
+        # )
+
+        print('\n'.join(render_package_listing_columns(*format_for_columns(outdated_pkgs))))
 
 
 if __name__ == '__main__':

omdev/pyproject/cli.py

@@ -40,7 +40,7 @@ from omlish.formats.toml.parser import toml_loads
 from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check
 from omlish.lite.runtime import check_lite_runtime_version
-from omlish.logs.standard import configure_standard_logging
+from omlish.logs.std.standard import configure_standard_logging
 
 from .configs import PyprojectConfig
 from .configs import PyprojectConfigPreparer

omdev/pyproject/tools/aboutdeps.py

@@ -38,11 +38,16 @@ def _main() -> None:
         pkg_opt_deps = {d for ds in pkg_prj.optional_dependencies.values() for d in ds}
         for opt_dep in sorted(pkg_opt_deps):
             opt_req = parse_requirement(opt_dep)
+
             opt_cn = canonicalize_name(opt_req.name, validate=True)
+
             opt_spec = Specifier(opt_req.specifier)
             if re.fullmatch(r'~=\s*\d+(\.\d+)*', str(opt_spec)):
                 opt_spec = Specifier(str(opt_spec) + '.0')
 
+            if opt_cn in pkgs:
+                continue
+
             opt_dist = dist_dct[opt_cn]
             opt_ver = opt_dist.version