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

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

@@ -22,7 +22,6 @@ See:
 import argparse
 import asyncio
 import concurrent.futures as cf
-import dataclasses as dc
 import functools
 import itertools
 import multiprocessing as mp
@@ -40,47 +39,14 @@ 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
 from .pkg import BasePyprojectPackageGenerator
 from .pkg import PyprojectPackageGenerator
 from .venvs import Venv
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class VersionsFile:
-    name: ta.Optional[str] = '.versions'
-
-    @staticmethod
-    def parse(s: str) -> ta.Mapping[str, str]:
-        return {
-            k: v
-            for l in s.splitlines()
-            if (sl := l.split('#')[0].strip())
-            for k, _, v in (sl.partition('='),)
-        }
-
-    @cached_nullary
-    def contents(self) -> ta.Mapping[str, str]:
-        if not self.name or not os.path.exists(self.name):
-            return {}
-        with open(self.name) as f:
-            s = f.read()
-        return self.parse(s)
-
-    @staticmethod
-    def get_pythons(d: ta.Mapping[str, str]) -> ta.Mapping[str, str]:
-        pfx = 'PYTHON_'
-        return {k[len(pfx):].lower(): v for k, v in d.items() if k.startswith(pfx)}
-
-    @cached_nullary
-    def pythons(self) -> ta.Mapping[str, str]:
-        return self.get_pythons(self.contents())
+from .versions import VersionsFile
 
 
 ##

omdev/pyproject/configs.py

@@ -24,7 +24,7 @@ class PyprojectConfig:
     venvs: ta.Mapping[str, VenvConfig] = dc.field(default_factory=dict)
 
     venvs_dir: str = '.venvs'
-    versions_file: ta.Optional[str] = '.versions'
+    # versions_file: ta.Optional[str] = '.versions'  # FIXME:
 
 
 class PyprojectConfigPreparer:

omdev/pyproject/pkg.py

@@ -587,7 +587,7 @@ class _PyprojectRsPackageGenerator(_PyprojectExtensionPackageGenerator):
             # `sdist.add_defaults` as an unbound function, not a bound method:
             # https://github.com/pypa/setuptools/blob/9c4d383631d3951fcae0afd73b5d08ff5a262976/setuptools/command/egg_info.py#L581
             from setuptools.command.sdist import sdist  # noqa
-            sdist.add_defaults = (lambda old: lambda sdist: _sdist_add_defaults(old, sdist))(sdist.add_defaults)  # noqa
+            setattr(sdist, 'add_defaults', (lambda old: lambda sdist: _sdist_add_defaults(old, sdist))(sdist.add_defaults))  # noqa
 
         _patch_sdist()
 

omdev/pyproject/reqs.py

@@ -53,13 +53,14 @@ class RequirementsRewriter:
                 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
+                    vs = set(rp.split())
+                    nvs = {v[1:] for v in vs if v.startswith('!')}
+                    pvs = {v for v in vs if not v.startswith('!')}
+                    if (
+                            (nvs and self._venv in nvs) or
+                            (pvs and self._venv not in pvs)
+                    ):
+                        omit = True
 
                 if (
                         not omit and

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
 

omdev/pyproject/tools/pyversions.py

@@ -0,0 +1,47 @@
+# ruff: noqa: UP006 UP045
+import dataclasses as dc
+import json
+import typing as ta
+import urllib.request
+
+from ..versions import VersionsFile
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class PyVersion:
+    name: str  # "Python 3.13.11",
+    slug: str  # "python-31311"
+    version: int  # 3
+    is_published: bool
+    is_latest: bool
+    release_date: str  # "2025-12-05T19:24:49Z"
+    pre_release: bool
+    release_page: ta.Optional[str]
+    release_notes_url: str  # "https://docs.python.org/release/3.13.11/whatsnew/changelog.html"
+    show_on_download_page: bool
+    resource_uri: str  # "https://www.python.org/api/v2/downloads/release/1083/"
+
+
+PY_VERSIONS_URL = 'https://www.python.org/api/v2/downloads/release/?is_published=true'
+
+
+def get_py_versions() -> ta.List[PyVersion]:
+    with urllib.request.urlopen(PY_VERSIONS_URL) as r:  # noqa
+        data = json.load(r)
+
+    return [PyVersion(**dct) for dct in data]
+
+
+##
+
+
+def _main() -> None:
+    print(get_py_versions())
+    print(VersionsFile().pythons())
+
+
+if __name__ == '__main__':
+    _main()

omdev/pyproject/versions.py

@@ -0,0 +1,40 @@
+# ruff: noqa: UP045
+import dataclasses as dc
+import os.path
+import typing as ta
+
+from omlish.lite.cached import cached_nullary
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class VersionsFile:
+    name: ta.Optional[str] = '.versions'
+
+    @staticmethod
+    def parse(s: str) -> ta.Mapping[str, str]:
+        return {
+            k: v
+            for l in s.splitlines()
+            if (sl := l.split('#')[0].strip())
+            for k, _, v in (sl.partition('='),)
+        }
+
+    @cached_nullary
+    def contents(self) -> ta.Mapping[str, str]:
+        if not self.name or not os.path.exists(self.name):
+            return {}
+        with open(self.name) as f:
+            s = f.read()
+        return self.parse(s)
+
+    @staticmethod
+    def get_pythons(d: ta.Mapping[str, str]) -> ta.Mapping[str, str]:
+        pfx = 'PYTHON_'
+        return {k[len(pfx):].lower(): v for k, v in d.items() if k.startswith(pfx)}
+
+    @cached_nullary
+    def pythons(self) -> ta.Mapping[str, str]:
+        return self.get_pythons(self.contents())