corio 2.2.2a2__tar.gz → 2.2.2a4__tar.gz

{corio-2.2.2a2 → corio-2.2.2a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: corio
-Version: 2.2.2a2
+Version: 2.2.2a4
 Summary: Collection of high-level tools to simplify everyday development tasks, with a focus on AI/ML
 Author-email: Frontmatter AI <innovative.fowler@mask.pro.fmtr.dev>
 License-Expression: Apache-2.0

{corio-2.2.2a2 → corio-2.2.2a4}/corio/infra/incrementor_pyproject.py

@@ -1,12 +1,15 @@
 from copy import deepcopy
 from functools import cached_property
 from itertools import chain
+from packaging.requirements import Requirement, InvalidRequirement
+from packaging.utils import canonicalize_name
 
 from corio.constants import Constants
 from corio.infra.releaser import Incrementor
 from corio.iterator import dedupe
 from corio.logs import logger
-from corio.path import Path
+from corio.path import Path, PackagePaths
+from corio.path.path import Metadata
 from corio.toml import ensure_table
 
 
@@ -25,6 +28,86 @@ class IncrementorPyproject(Incrementor):
     def name_command(self) -> str:
         return self.paths.name_ns.replace(".", self.ENTRYPOINT_COMMAND_SEP)
 
+    @cached_property
+    def editables(self) -> dict[str, Metadata]:
+        data = self.path.read_toml()
+        sources = data.get("tool", {}).get("uv", {}).get("sources", {})
+
+        editables = {}
+        for key, source in sources.items():
+            if not isinstance(source, dict):
+                continue
+            if not source.get("editable"):
+                continue
+
+            source_path = source.get("path")
+            if not source_path:
+                logger.warning(f'Editable source "{key}" is missing "path". Skipping.')
+                continue
+            path_repo = (self.paths.repo / str(source_path)).resolve()
+            if not path_repo.exists():
+                continue
+
+            try:
+                paths = PackagePaths(path_repo)
+            except Exception as exception:
+                logger.warning(f'Failed to resolve editable source at "{path_repo}". Skipping. {exception!r}')
+                continue
+
+            metadata = paths.metadata
+            if metadata.version_obj.prerelease and not self.versions.is_pre:
+                raise ValueError(
+                    f'Editable dependency "{paths.name_ns}" is pre-release '
+                    f'({metadata.version_obj.prerelease}) while "{self.paths.name_ns}" is release. Refusing to pin.'
+                )
+
+            editables[paths.name_ns] = metadata
+            editables[canonicalize_name(paths.name_ns)] = metadata
+
+        return editables
+
+    def _pin_editable(self, dep: str) -> str:
+        try:
+            requirement = Requirement(dep)
+        except InvalidRequirement:
+            return dep
+
+        if requirement.specifier:
+            return dep
+        if requirement.url:
+            return dep
+
+        metadata = self.editables.get(requirement.name)
+        if metadata is None:
+            metadata = self.editables.get(canonicalize_name(requirement.name))
+        if metadata is None:
+            return dep
+
+        extras = ""
+        if requirement.extras:
+            extras = f"[{','.join(sorted(requirement.extras))}]"
+
+        marker = ""
+        if requirement.marker:
+            marker = f"; {requirement.marker}"
+
+        pinned = f"{requirement.name}{extras}=={metadata.version}{marker}"
+        logger.info(f'Pinning editable dependency "{dep}" -> "{pinned}".')
+        return pinned
+
+    def _process_deps(self, deps: str|list[str]) -> str|list[str]:
+
+        if isinstance(deps, list):
+            deps=[self._process_deps(dep) for dep in deps]
+            deps=dedupe(deps)
+            return deps
+
+        dep=deps
+        dep=self._pin_editable(dep)
+
+        return dep
+
+
     def apply(self) -> Path | list[Path] | None:
         if not self.path.exists():
             logger.info(f'pyproject.toml not found: "{self.path}". Skipping.')
@@ -43,6 +126,7 @@ class IncrementorPyproject(Incrementor):
         self.path.write_toml(data)
         return self.path
 
+
     @property
     def _author(self) -> str:
         if self.paths.metadata.is_client:
@@ -106,36 +190,23 @@ class IncrementorPyproject(Incrementor):
                     values_resolved += resolve_values(value)
             return values_resolved
 
-        install = dedupe(resolve_values("install")) if "install" in dependencies else []
+
         extras = {key: dedupe(resolve_values(key)) for key in dependencies}
-        extras.pop("install", None)
+        install = extras.pop("install", [])
         extras["all"] = dedupe(list(chain.from_iterable(extras.values())))
         return install, extras
 
-    def _get_dependencies(self, data) -> dict[str, list[str]]:
-        table = data
-        for key in self.DEPENDENCIES_SECTION_PATH:
-            if key not in table:
-                return {}
-            table = table[key]
-
-        if table is None:
-            return {}
-        return {str(key): [str(value) for value in values] for key, values in table.items()}
 
     def _enrich_toml(self, data):
-        old = self.versions.old
-        new = self._bump(old)
-        if old != new:
-            logger.info(f'Incrementing version "{self.path}" {old} {Constants.ARROW_RIGHT} {new}...')
-        self.paths.metadata.version = str(new)
+        version = str(self.version)
+        logger.info(f'Applying release version "{version}" to "{self.path}"...')
 
         metadata = ensure_table(data, ("tool", "corio", "metadata"))
-        metadata["version"] = self.paths.metadata.version
+        metadata["version"] = version
 
         project = ensure_table(data, ("project",))
         project["name"] = self.paths.name_ns
-        project["version"] = self.paths.metadata.version
+        project["version"] = version
         project["description"] = self.paths.metadata.description
         project["keywords"] = self.paths.metadata.keywords
         project["readme"] = self.paths.readme.name
@@ -146,18 +217,32 @@ class IncrementorPyproject(Incrementor):
         elif "license-files" in project:
             del project["license-files"]
 
-        dependencies = self._get_dependencies(data)
-        if dependencies:
-            install, extras = self._flatten_dependencies(dependencies)
+
+        deps_corio = data.get("tool", {}).get("corio", {}).get("dependencies", None)
+        if deps_corio is not None:
+            install, extras = self._flatten_dependencies(deps_corio)
             project["dependencies"] = install
             project["optional-dependencies"] = extras
-
-            if "dev" in extras:
-                dependency_groups = ensure_table(data, ("dependency-groups",))
-                dependency_groups["dev"] = list(extras["dev"])
         else:
             logger.info(f'No dependencies section found in "{self.path}". Skipping dependency enrichment.')
 
+
+        deps = project.get("dependencies")
+        if deps is not None:
+            project["dependencies"] = self._process_deps(deps)
+
+        optionals = project.get("optional-dependencies")
+        if optionals is not None:
+            optionals = {
+                key: self._process_deps(values)
+                for key, values in optionals.items()
+            }
+            project["optional-dependencies"] = optionals
+
+            if "dev" in optionals:
+                dependency_groups = ensure_table(data, ("dependency-groups",))
+                dependency_groups["dev"] = list(optionals["dev"])
+
         urls = ensure_table(project, ("urls",))
         urls["Homepage"] = self.repo_url
 
@@ -187,11 +272,3 @@ class IncrementorPyproject(Incrementor):
             del setuptools["script-files"]
 
         return data
-
-    def _bump(self, version):
-        if self.versions.pinned:
-            return self.versions.pinned
-
-        if version.prerelease:
-            return version.bump_prerelease()
-        return version.bump_patch()

{corio-2.2.2a2 → corio-2.2.2a4}/corio/infra/releaser.py

@@ -45,6 +45,10 @@ class Releaser(Inherit[Project]):
 
         from corio.infra.stack import ProductionPrivate, ProductionPublic
 
+        if increment:
+            self.repo.fetch()
+            self.increment()
+
         is_passed = self.tester.run()
         if not is_passed:
             if self.versions.is_pre:
@@ -53,8 +57,6 @@ class Releaser(Inherit[Project]):
                 raise RuntimeError("Tests failed. Aborting release.")
 
         if increment:
-            self.repo.fetch()
-            self.increment()
             self.repo.push()
             self.repo.fetch()
 
@@ -157,6 +159,7 @@ class Releaser(Inherit[Project]):
 
         return IndexList[Incrementor](
             [
+                IncrementorVersion(self),
                 IncrementorPyproject(self),
                 IncrementorHomeAssistantAddon(self),
                 IncrementorChangelog(self),
@@ -212,6 +215,24 @@ class Incrementor(Inherit[Releaser]):
         raise NotImplementedError
 
 
+class IncrementorVersion(Incrementor):
+    @logger.instrument('Incrementing release version in-memory for "{self.paths.name_ns}"...')
+    def apply(self) -> Path | list[Path] | None:
+        old = self.versions.old
+        if self.versions.pinned:
+            new = self.versions.pinned
+        elif old.prerelease:
+            new = old.bump_prerelease()
+        else:
+            new = old.bump_patch()
+
+        if old != new:
+            logger.info(f'Incrementing runtime version {old} {Constants.ARROW_RIGHT} {new}...')
+
+        self.paths.metadata.version = str(new)
+        return None
+
+
 
 
 

{corio-2.2.2a2 → corio-2.2.2a4}/corio/pyproject.package.toml

@@ -64,7 +64,7 @@ secrets = ["encrypt", "env.io", "yaml", "logging", "sets", "vcs"]
 cli = ["sets", "logging"]
 
 [tool.corio.metadata]
-version = "2.2.2-alpha002"
+version = "2.2.2-alpha004"
 port = 0
 base = "python"
 description = "Collection of high-level tools to simplify everyday development tasks, with a focus on AI/ML"
@@ -94,7 +94,7 @@ corio = ["pyproject.package.toml"]
 
 [project]
 name = "corio"
-version = "2.2.2-alpha002"
+version = "2.2.2-alpha004"
 description = "Collection of high-level tools to simplify everyday development tasks, with a focus on AI/ML"
 readme = "README.md"
 dependencies = []

corio-2.2.2a4/corio/tests/test_infra.py

@@ -0,0 +1,163 @@
+from types import SimpleNamespace
+
+from packaging.requirements import Requirement
+
+from corio.infra.incrementor_pyproject import IncrementorPyproject
+from corio.path import Path
+
+
+def _write_editable_repo(path_repo: Path, name: str, version: str) -> None:
+    (path_repo / "pyproject.toml").write_text("", encoding="utf-8")
+    path_package = path_repo / name
+    path_package.mkdir(parents=True)
+    (path_package / "pyproject.package.toml").write_text(
+        f'[tool.corio.metadata]\nversion = "{version}"\n',
+        encoding="utf-8",
+    )
+
+
+def _make_incrementor(path_repo: Path, is_pre: bool = False) -> IncrementorPyproject:
+    parent = SimpleNamespace(
+        paths=SimpleNamespace(
+            repo=path_repo,
+            pyproject_repo=path_repo / "pyproject.toml",
+            name_ns="corio",
+        ),
+        versions=SimpleNamespace(is_pre=is_pre),
+    )
+    return IncrementorPyproject(parent)
+
+
+def test_pin_editables_and_flatten_dependencies(tmp_path):
+    path_main_repo = Path(tmp_path / "corio")
+    path_main_repo.mkdir(parents=True)
+
+    path_haco_repo = Path(path_main_repo / "haco")
+    path_haco_repo.mkdir(parents=True)
+    _write_editable_repo(path_haco_repo, name="haco", version="1.2.3")
+
+    (path_main_repo / "pyproject.toml").write_text(
+        '[tool.uv.sources.haco]\npath = "haco"\neditable = true\n',
+        encoding="utf-8",
+    )
+
+    incrementor = _make_incrementor(path_main_repo)
+
+    assert incrementor._pin_editable("haco") == "haco==1.2.3"
+    assert incrementor._pin_editable("requests") == "requests"
+
+    install, extras = incrementor._flatten_dependencies(
+        {
+            "install": ["haco", "requests"],
+            "dev": ["haco"],
+        }
+    )
+
+    assert install == ["haco", "requests"]
+    assert extras == {"dev": ["haco"], "all": ["haco"]}
+
+
+def test_pin_editables_resolves_uv_source_path(tmp_path):
+    path_main_repo = Path(tmp_path / "app")
+    path_main_repo.mkdir(parents=True)
+
+    path_corio_repo = Path(tmp_path / "corio")
+    path_corio_repo.mkdir(parents=True)
+    _write_editable_repo(path_corio_repo, name="corio", version="1.2.3")
+
+    (path_main_repo / "pyproject.toml").write_text(
+        '[tool.uv.sources.corio]\npath = "../corio"\neditable = true\n',
+        encoding="utf-8",
+    )
+
+    incrementor = _make_incrementor(path_main_repo)
+    assert incrementor._pin_editable("corio") == "corio==1.2.3"
+
+
+def test_pin_editables_preserves_extras_and_skips_existing_specifiers(tmp_path):
+    path_main_repo = Path(tmp_path / "corio")
+    path_main_repo.mkdir(parents=True)
+
+    path_haco_repo = Path(path_main_repo / "haco")
+    path_haco_repo.mkdir(parents=True)
+    _write_editable_repo(path_haco_repo, name="haco", version="1.2.3")
+
+    (path_main_repo / "pyproject.toml").write_text(
+        '[tool.uv.sources.haco]\npath = "haco"\neditable = true\n',
+        encoding="utf-8",
+    )
+
+    incrementor = _make_incrementor(path_main_repo)
+
+    dep = incrementor._pin_editable("haco[version.dev,logging,sets,yaml,debug,caching,api,mqtt]")
+    req = Requirement(dep)
+    assert req.name == "haco"
+    assert req.extras == {"version.dev", "logging", "sets", "yaml", "debug", "caching", "api", "mqtt"}
+    assert str(req.specifier) == "==1.2.3"
+
+    assert incrementor._pin_editable("haco==1.0.0") == "haco==1.0.0"
+    assert incrementor._pin_editable("haco>=1.0.0") == "haco>=1.0.0"
+
+
+def test_pin_editables_raises_on_prerelease_when_current_is_release(tmp_path):
+    path_main_repo = Path(tmp_path / "corio")
+    path_main_repo.mkdir(parents=True)
+
+    path_haco_repo = Path(path_main_repo / "haco")
+    path_haco_repo.mkdir(parents=True)
+    _write_editable_repo(path_haco_repo, name="haco", version="1.2.3-rc.1")
+
+    (path_main_repo / "pyproject.toml").write_text(
+        '[tool.uv.sources.haco]\npath = "haco"\neditable = true\n',
+        encoding="utf-8",
+    )
+
+    incrementor = _make_incrementor(path_main_repo, is_pre=False)
+
+    try:
+        _ = incrementor.editables
+    except ValueError as exception:
+        assert 'Editable dependency "haco" is pre-release' in str(exception)
+    else:
+        raise AssertionError("Expected ValueError for prerelease editable dependency")
+
+
+def test_pin_editables_allows_prerelease_when_current_is_prerelease(tmp_path):
+    path_main_repo = Path(tmp_path / "corio")
+    path_main_repo.mkdir(parents=True)
+
+    path_haco_repo = Path(path_main_repo / "haco")
+    path_haco_repo.mkdir(parents=True)
+    _write_editable_repo(path_haco_repo, name="haco", version="1.2.3-rc.1")
+
+    (path_main_repo / "pyproject.toml").write_text(
+        '[tool.uv.sources.haco]\npath = "haco"\neditable = true\n',
+        encoding="utf-8",
+    )
+
+    incrementor = _make_incrementor(path_main_repo, is_pre=True)
+
+    assert incrementor._pin_editable("haco") == "haco==1.2.3-rc.1"
+
+
+def test_process_deps_pins_project_dependencies(tmp_path):
+    path_main_repo = Path(tmp_path / "corio")
+    path_main_repo.mkdir(parents=True)
+
+    path_haco_repo = Path(path_main_repo / "haco")
+    path_haco_repo.mkdir(parents=True)
+    _write_editable_repo(path_haco_repo, name="haco", version="1.2.3")
+
+    (path_main_repo / "pyproject.toml").write_text(
+        '[tool.uv.sources.haco]\npath = "haco"\neditable = true\n',
+        encoding="utf-8",
+    )
+
+    incrementor = _make_incrementor(path_main_repo)
+
+    dependencies = ["haco", "requests>=2"]
+    optional_dev = ["haco[logging]", "pytest"]
+
+    assert incrementor._process_deps(dependencies) == ["haco==1.2.3", "requests>=2"]
+    assert incrementor._process_deps(optional_dev) == ["haco[logging]==1.2.3", "pytest"]
+

{corio-2.2.2a2 → corio-2.2.2a4}/corio.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: corio
-Version: 2.2.2a2
+Version: 2.2.2a4
 Summary: Collection of high-level tools to simplify everyday development tasks, with a focus on AI/ML
 Author-email: Frontmatter AI <innovative.fowler@mask.pro.fmtr.dev>
 License-Expression: Apache-2.0

{corio-2.2.2a2 → corio-2.2.2a4}/corio.egg-info/SOURCES.txt

@@ -104,6 +104,7 @@ corio/tests/test_caching.py
 corio/tests/test_datatype.py
 corio/tests/test_encrypt.py
 corio/tests/test_env.py
+corio/tests/test_infra.py
 corio/tests/test_jsn.py
 corio/tests/test_path.py
 corio/tests/test_yaml.py

{corio-2.2.2a2 → corio-2.2.2a4}/pyproject.toml

@@ -64,7 +64,7 @@ secrets = ["encrypt", "env.io", "yaml", "logging", "sets", "vcs"]
 cli = ["sets", "logging"]
 
 [tool.corio.metadata]
-version = "2.2.2-alpha002"
+version = "2.2.2-alpha004"
 port = 0
 base = "python"
 description = "Collection of high-level tools to simplify everyday development tasks, with a focus on AI/ML"
@@ -94,7 +94,7 @@ corio = ["pyproject.package.toml"]
 
 [project]
 name = "corio"
-version = "2.2.2-alpha002"
+version = "2.2.2-alpha004"
 description = "Collection of high-level tools to simplify everyday development tasks, with a focus on AI/ML"
 readme = "README.md"
 dependencies = []