corio 2.2.2a4__tar.gz → 2.2.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: corio
-Version: 2.2.2a4
+Version: 2.2.4
 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
@@ -188,6 +188,8 @@ Requires-Dist: httpx; extra == "dns"
 Requires-Dist: httpx_retries; extra == "dns"
 Requires-Dist: logfire; extra == "dns"
 Requires-Dist: logfire[httpx]; extra == "dns"
+Requires-Dist: diskcache; extra == "dns"
+Requires-Dist: cachetools; extra == "dns"
 Provides-Extra: patterns
 Requires-Dist: regex; extra == "patterns"
 Provides-Extra: http
@@ -214,6 +216,9 @@ Requires-Dist: av; extra == "av"
 Provides-Extra: env
 Provides-Extra: env-io
 Requires-Dist: dotenv; extra == "env-io"
+Provides-Extra: toml
+Provides-Extra: toml-write
+Requires-Dist: tomlkit; extra == "toml-write"
 Provides-Extra: ha
 Requires-Dist: dotenv; extra == "ha"
 Provides-Extra: ha-api

{corio-2.2.2a4 → corio-2.2.4}/corio/entrypoint.py

@@ -3,6 +3,7 @@ from pydantic_settings import CliSubCommand
 from corio import dm
 from corio import sec
 from corio import sets
+from corio.path import Path
 
 
 class DocServe(dm.Base):
@@ -42,6 +43,17 @@ class EpTest(dm.Base):
         print("Ran test entrypoint.")
 
 
+class Test(dm.Base):
+    name: str = Path.cwd().name
+
+    def run(self):
+        from corio.infra.project import Project
+
+        project = Project(self.name)
+        is_passed = project.releaser.tester.run()
+        return int(not is_passed)
+
+
 class ShellDebug(dm.Base):
     def run(self):
         from corio import debug
@@ -81,6 +93,7 @@ class Cli(sets.Base, cli_parse_args=True):
     secrets: CliSubCommand[sec.Cli]
     docs: CliSubCommand[Docs]
     pyproject: CliSubCommand[Pyproject]
+    test: CliSubCommand[Test]
     ep_test: CliSubCommand[EpTest]
     shell_debug: CliSubCommand[ShellDebug]
     cache_hfh: CliSubCommand[CacheHfh]

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

@@ -72,8 +72,6 @@ class IncrementorPyproject(Incrementor):
         except InvalidRequirement:
             return dep
 
-        if requirement.specifier:
-            return dep
         if requirement.url:
             return dep
 
@@ -83,6 +81,11 @@ class IncrementorPyproject(Incrementor):
         if metadata is None:
             return dep
 
+        if requirement.specifier:
+            operators = {specifier.operator for specifier in requirement.specifier}
+            if not operators.issubset({"==", "==="}):
+                return dep
+
         extras = ""
         if requirement.extras:
             extras = f"[{','.join(sorted(requirement.extras))}]"

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

@@ -525,6 +525,7 @@ class ReleaseDocumentation(Release):
                 {"pymdownx.tabbed": {"alternate_style": True}},
                 {"pymdownx.emoji": {"emoji_index": twemoji, "emoji_generator": to_svg}},
             ],
+            exclude_docs="*.hidden.md\n**/*.hidden.md",
             extra={
                 "version": {"provider": "mike"},
             },
@@ -583,13 +584,7 @@ class Tester(Inherit[Releaser]):
     @cached_property
     def dependencies(self) -> dict[str, list[str]]:
         data = self.paths.pyproject_repo.read_toml()
-        table = data.get("tool", {}).get("corio", {}).get("dependencies", {})
-        dependencies = {
-            str(key): [str(value) for value in values]
-            for key, values in table.items()
-            if isinstance(values, list)
-        }
-        return dependencies
+        return data["project"].get("optional-dependencies",{})
 
     @cached_property
     def modules(self) -> list[str]:
@@ -607,9 +602,11 @@ class Tester(Inherit[Releaser]):
     def get_env(self, name: str, path_tests: Path, extras: list[str]) -> dict:
         if path_tests.is_relative_to(self.paths.repo):
             path_tests = path_tests.relative_to(self.paths.repo)
+        deps = self.get_deps_extras(extras)
         env = {
             "description": f"Run {name} tests.",
             "extras": extras,
+            "deps": deps,
             "commands": [["python", "-m", "pytest", "-q", str(path_tests)]],
         }
         return env
@@ -618,6 +615,22 @@ class Tester(Inherit[Releaser]):
     def env(self) -> dict:
         return self.get_env(name=self.paths.name_ns, path_tests=self.paths.tests, extras=["test"])
 
+    def get_extras_module(self, module: str) -> list[str]:
+        extras = ["test"]
+        extras_available = set(self.dependencies.keys())
+
+        if module in extras_available:
+            extras.insert(0, module)
+
+        extras_children = sorted(extra for extra in extras_available if extra.startswith(f"{module}."))
+        return extras_children + extras
+
+    def get_deps_extras(self, extras: list[str]) -> list[str]:
+        resolved = []
+        for extra in extras:
+            resolved.extend(self.dependencies.get(extra, []))
+        return list(dict.fromkeys(resolved))
+
     @cached_property
     def envs(self) -> dict[str, dict]:
         if not self.paths.metadata.test_envs:
@@ -626,12 +639,9 @@ class Tester(Inherit[Releaser]):
             return {self.paths.name_ns: self.env}
 
         envs = {}
-        extras_available = set(self.dependencies.keys())
 
         for module in self.modules:
-            extras = ["test"]
-            if module in extras_available:
-                extras.insert(0, module)
+            extras = self.get_extras_module(module)
 
             path_test = self.paths.tests / f"{self.TEST_FILENAME_PREFIX}{module}{self.TEST_FILENAME_SUFFIX}"
             name = f"{self.paths.name_ns}.{module}"

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

@@ -40,7 +40,7 @@ debug = ["pydevd-pycharm~=251.25410.159"]
 sets = ["pydantic-settings", "dm", "yaml"]
 "path.app" = ["appdirs"]
 "path.type" = ["filetype"]
-dns = ["dnspython[doh]", "http"]
+dns = ["dnspython[doh]", "http", "caching"]
 patterns = ["regex"]
 http = ["httpx", "httpx_retries", "logging", "logfire[httpx]"]
 setup = ["setuptools"]
@@ -52,11 +52,13 @@ mqtt = ["aiomqtt"]
 av = ["av"]
 env = []
 "env.io" = ["dotenv"]
+toml = []
+"toml.write" = ["tomlkit"]
 ha = ["env.io"]
 "ha.api" = ["ha", "homeassistant_api", "aiohasupervisor"]
 doc = ["mkdocs", "mkdocs-material", "mkdocstrings[python]", "mike", "mkdocs-include-dir-to-nav"]
 youtube = ["pytubefix"]
-infra = ["version.dev", "logging", "setup", "doc", "sets", "build", "twine", "packaging", "vcs", "docker.client", "merging", "http", "api", "tomlkit", "secrets", "cli", "test"]
+infra = ["version.dev", "logging", "setup", "doc", "sets", "build", "twine", "packaging", "vcs", "docker.client", "merging", "http", "api", "toml.write", "secrets", "cli", "test"]
 vcs = ["pygit2"]
 tasmota = ["decode-config", "esptool"]
 encrypt = ["pyrage"]
@@ -64,7 +66,7 @@ secrets = ["encrypt", "env.io", "yaml", "logging", "sets", "vcs"]
 cli = ["sets", "logging"]
 
 [tool.corio.metadata]
-version = "2.2.2-alpha004"
+version = "2.2.4"
 port = 0
 base = "python"
 description = "Collection of high-level tools to simplify everyday development tasks, with a focus on AI/ML"
@@ -94,7 +96,7 @@ corio = ["pyproject.package.toml"]
 
 [project]
 name = "corio"
-version = "2.2.2-alpha004"
+version = "2.2.4"
 description = "Collection of high-level tools to simplify everyday development tasks, with a focus on AI/ML"
 readme = "README.md"
 dependencies = []
@@ -139,7 +141,7 @@ debug = ["pydevd-pycharm~=251.25410.159"]
 sets = ["pydantic-settings", "pydantic", "pydantic-extra-types", "pycountry", "yamlscript", "pyyaml"]
 "path.app" = ["appdirs"]
 "path.type" = ["filetype"]
-dns = ["dnspython[doh]", "httpx", "httpx_retries", "logfire", "logfire[httpx]"]
+dns = ["dnspython[doh]", "httpx", "httpx_retries", "logfire", "logfire[httpx]", "diskcache", "cachetools"]
 patterns = ["regex"]
 http = ["httpx", "httpx_retries", "logfire", "logfire[httpx]"]
 setup = ["setuptools"]
@@ -151,6 +153,8 @@ mqtt = ["aiomqtt"]
 av = ["av"]
 env = []
 "env.io" = ["dotenv"]
+toml = []
+"toml.write" = ["tomlkit"]
 ha = ["dotenv"]
 "ha.api" = ["dotenv", "homeassistant_api", "aiohasupervisor"]
 doc = ["mkdocs", "mkdocs-material", "mkdocstrings[python]", "mike", "mkdocs-include-dir-to-nav"]

corio-2.2.4/corio/tests/test_dns.py

@@ -0,0 +1,89 @@
+import dns
+from dns import rcode as dnspython_rcode
+
+from corio.dns import client as dns_client
+from corio.dns import dm as dns_dm
+
+
+def _make_exchange(name: str = "example.com.", rdtype=dns.rdatatype.A) -> dns_dm.Exchange:
+    query = dns.message.make_query(name, rdtype)
+    return dns_dm.Exchange.from_wire(query.to_wire(), ip="127.0.0.1", port=5353)
+
+
+def test_response_ttl_from_answers_authority_and_rcode_defaults():
+    exchange = _make_exchange()
+    message = exchange.request.get_response_template()
+    message.answer.append(dns.rrset.from_text("example.com.", 300, "IN", "A", "1.1.1.1"))
+    message.answer.append(dns.rrset.from_text("example.com.", 120, "IN", "A", "1.1.1.2"))
+    response = dns_dm.Response.from_message(message)
+    assert response.ttl == 120
+
+    message = exchange.request.get_response_template()
+    message.authority.append(dns.rrset.from_text("example.com.", 42, "IN", "NS", "ns1.example.com."))
+    response = dns_dm.Response.from_message(message)
+    assert response.ttl == 42
+
+    message = exchange.request.get_response_template()
+    message.set_rcode(dnspython_rcode.SERVFAIL)
+    response = dns_dm.Response.from_message(message)
+    assert response.ttl == 10
+
+    response = dns_dm.Response.from_message(message, ttl_defaults={"SERVFAIL": 77})
+    assert response.ttl == 77
+
+
+def test_exchange_question_last_and_query_last_use_latest_answer_name():
+    exchange = _make_exchange(name="example.com.")
+    message = exchange.request.get_response_template()
+    message.answer.append(dns.rrset.from_text("edge.example.com.", 60, "IN", "A", "9.9.9.9"))
+    exchange.response = dns_dm.Response.from_message(message)
+
+    question_last = exchange.question_last
+    assert question_last.name.to_text() == "9.9.9.9"
+    assert question_last.rdtype == exchange.request.type
+
+    query_last = exchange.query_last
+    assert query_last.question[0].name.to_text() == "9.9.9.9"
+    assert query_last.id == exchange.request.message.id
+
+
+def test_exchange_reverse_builds_internal_ptr_query():
+    exchange = _make_exchange()
+    reverse = exchange.reverse
+
+    assert reverse.is_internal is True
+    assert reverse.ip == exchange.ip
+    assert reverse.port == exchange.port
+    assert reverse.request.type_text == "PTR"
+    assert reverse.request.name_text.endswith(".in-addr.arpa.")
+
+
+def test_plain_client_resolve_applies_ttl_min(monkeypatch):
+    exchange = _make_exchange()
+    upstream = exchange.request.get_response_template()
+    upstream.answer.append(dns.rrset.from_text("example.com.", 3, "IN", "A", "1.1.1.1"))
+
+    monkeypatch.setattr(dns_client.dnspython_query, "udp", lambda q, where, port: upstream)
+
+    client_plain = dns_client.Plain(host="8.8.8.8", ttl_min=30)
+    client_plain.resolve(exchange)
+
+    assert exchange.response.answer is not None
+    assert exchange.response.answer.ttl == 30
+
+
+def test_http_client_resolve_sets_servfail_on_exception(monkeypatch):
+    exchange = _make_exchange()
+    client_http = dns_client.HTTP(host="dns.google", url="https://{host}/dns-query")
+    client_http.__dict__["ip"] = "1.1.1.1"
+
+    def _raise(*_args, **_kwargs):
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr(dns_client, "logger", type("L", (), {"exception": staticmethod(lambda *_args, **_kwargs: None)})())
+    monkeypatch.setattr(client_http.CLIENT, "post", _raise)
+
+    client_http.resolve(exchange)
+
+    assert exchange.response.rcode == dnspython_rcode.SERVFAIL
+    assert exchange.response.is_complete is True

corio-2.2.4/corio/tests/test_dt.py

@@ -0,0 +1,10 @@
+from datetime import timezone
+
+from corio import dt
+
+
+def test_now_is_utc_and_in_bounds():
+    value = dt.now()
+
+    assert value.tzinfo == timezone.utc
+    assert dt.MIN <= value <= dt.MAX

{corio-2.2.2a4 → corio-2.2.4}/corio/tests/test_env.py

@@ -73,3 +73,13 @@ def test_get_env_dict():
     with helpers.patch_environment(clear=True, **ENVIRONMENT_DATA):
         actual = env.get_dict()
     assert actual == expected
+
+
+def test_env_file_round_trip_via_path_data(tmp_path):
+    path_env = Path(tmp_path / ".env")
+    expected = {"A": "1", "B": "two"}
+
+    path_env.write_data(expected)
+    actual = path_env.read_data()
+
+    assert actual == expected

corio-2.2.4/corio/tests/test_hash.py

@@ -0,0 +1,18 @@
+from corio import hash as hash_module
+
+
+def test_hash_unit_is_stable_and_bounded():
+    first = hash_module.hash_unit("corio")
+    second = hash_module.hash_unit("corio")
+
+    assert first == second
+    assert 0.0 <= first < 1.0
+
+
+def test_get_hash_readable_length_and_replacements():
+    value = hash_module.get_hash_readable("corio", length=16)
+
+    assert len(value) == 16
+    assert "O" not in value
+    assert "I" not in value
+    assert "=" not in value

corio-2.2.4/corio/tests/test_hook.py

@@ -0,0 +1,28 @@
+import pytest
+
+from corio.hook import ImportHook, MissingExtraError, MissingExtraMockModule
+
+
+def test_missing_extra_mock_module_raises_with_context():
+    mock_module = MissingExtraMockModule("path.app", ModuleNotFoundError("no appdirs"))
+
+    with pytest.raises(MissingExtraError):
+        mock_module()
+
+    with pytest.raises(MissingExtraError):
+        _ = mock_module.any_attr
+
+
+def test_import_hook_translates_module_not_found_for_corio_callers():
+    hook = ImportHook(auto_register=False)
+
+    def fake_import(*_args, **_kwargs):
+        raise ModuleNotFoundError("missing dep")
+
+    hook._previous_import = fake_import
+
+    with pytest.raises(MissingExtraError):
+        hook("missing", globals={"__name__": "corio.path.app"})
+
+    with pytest.raises(ModuleNotFoundError):
+        hook("missing", globals={"__name__": "external.module"})

{corio-2.2.2a4 → corio-2.2.4}/corio/tests/test_infra.py

@@ -3,6 +3,7 @@ from types import SimpleNamespace
 from packaging.requirements import Requirement
 
 from corio.infra.incrementor_pyproject import IncrementorPyproject
+from corio.infra.releaser import Tester as ReleaserTester
 from corio.path import Path
 
 
@@ -95,7 +96,7 @@ def test_pin_editables_preserves_extras_and_skips_existing_specifiers(tmp_path):
     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.2.3"
     assert incrementor._pin_editable("haco>=1.0.0") == "haco>=1.0.0"
 
 
@@ -161,3 +162,87 @@ def test_process_deps_pins_project_dependencies(tmp_path):
     assert incrementor._process_deps(dependencies) == ["haco==1.2.3", "requests>=2"]
     assert incrementor._process_deps(optional_dev) == ["haco[logging]==1.2.3", "pytest"]
 
+
+def _make_tester(path_repo: Path, *, test_envs: bool) -> ReleaserTester:
+    path_tests = path_repo / "corio" / "tests"
+    path_tests.mkdir(parents=True)
+    path_pyproject = path_repo / "pyproject.toml"
+    path_pyproject.write_text(
+        "\n".join(
+            [
+                "[project]",
+                'name = "corio"',
+                'version = "0.0.0"',
+                "",
+                "[project.optional-dependencies]",
+                'test = ["pytest", "pytest-cov"]',
+                'path = []',
+                '"path.app" = ["appdirs"]',
+                '"path.type" = ["filetype"]',
+                "strings = []",
+                "",
+            ]
+        ),
+        encoding="utf-8",
+    )
+    parent = SimpleNamespace(
+        name="corio",
+        paths=SimpleNamespace(
+            repo=path_repo,
+            tests=path_tests,
+            pyproject_repo=path_pyproject,
+            name_ns="corio",
+            metadata=SimpleNamespace(test_envs=test_envs),
+        ),
+    )
+    return ReleaserTester(parent)
+
+
+def test_tester_get_extras_module_merges_module_and_dotted_children(tmp_path):
+    path_repo = Path(tmp_path / "corio")
+    path_repo.mkdir(parents=True)
+    tester = _make_tester(path_repo, test_envs=True)
+
+    assert tester.get_extras_module("path") == ["path.app", "path.type", "path", "test"]
+    assert tester.get_extras_module("strings") == ["strings", "test"]
+    assert tester.get_extras_module("missing") == ["test"]
+
+
+def test_tester_get_deps_extras_resolves_recursive_dependencies(tmp_path):
+    path_repo = Path(tmp_path / "corio")
+    path_repo.mkdir(parents=True)
+    tester = _make_tester(path_repo, test_envs=True)
+
+    deps = tester.get_deps_extras(["path.app", "path.type", "test"])
+    assert "pytest" in deps
+    assert "pytest-cov" in deps
+
+    deps_missing = tester.get_deps_extras(["missing"])
+    assert deps_missing == []
+
+
+def test_tester_envs_use_file_module_name_with_test_envs(tmp_path):
+    path_repo = Path(tmp_path / "corio")
+    path_repo.mkdir(parents=True)
+    tester = _make_tester(path_repo, test_envs=True)
+    (tester.paths.tests / "test_path.py").write_text("", encoding="utf-8")
+    (tester.paths.tests / "test_strings.py").write_text("", encoding="utf-8")
+
+    envs = tester.envs
+
+    assert set(envs) == {"corio.path", "corio.strings"}
+    assert envs["corio.path"]["extras"] == ["path.app", "path.type", "path", "test"]
+    assert envs["corio.strings"]["extras"] == ["strings", "test"]
+    assert "pytest" in envs["corio.path"]["deps"]
+
+
+def test_tester_envs_fall_back_to_single_env_when_test_envs_disabled(tmp_path):
+    path_repo = Path(tmp_path / "corio")
+    path_repo.mkdir(parents=True)
+    tester = _make_tester(path_repo, test_envs=False)
+    (tester.paths.tests / "test_path.py").write_text("", encoding="utf-8")
+
+    envs = tester.envs
+
+    assert set(envs) == {"corio"}
+    assert envs["corio"]["extras"] == ["test"]

corio-2.2.4/corio/tests/test_iterator.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass
+
+from corio import iterator
+
+
+def test_enlist_and_dedupe():
+    assert iterator.enlist("x") == ["x"]
+    assert iterator.enlist(["x"]) == ["x"]
+    assert iterator.dedupe(["a", "b", "a", "c"]) == ["a", "b", "c"]
+
+
+def test_dict_records_to_lists_and_chunking():
+    data = [{"a": 1}, {"b": 2}]
+    as_lists = iterator.dict_records_to_lists(data, missing=None)
+    assert as_lists == {"a": [1, None], "b": [None, 2]}
+
+    assert iterator.chunk_data([1, 2, 3, 4, 5], size=2) == [[1, 2], [3, 4], [5]]
+    assert iterator.get_batch_sizes(total=10, num_batches=3) == [4, 3, 3]
+    assert list(iterator.rebatch([[1, 2], [3], [4, 5]], size=2)) == [(1, 2), (3, 4), (5,)]
+
+
+def test_strip_none_flatten_tree_and_iterdiffer():
+    assert iterator.strip_none(1, None, 2) == [1, 2]
+
+    tree = {"a": {"b": 1}, "list": [2, 3]}
+    flat = iterator.flatten_tree(tree, sep=".")
+    assert flat["a.b"] == 1
+    assert flat["list.[0]"] == 2
+    assert flat["list.[1]"] == 3
+
+    diff = iterator.IterDiffer(before=[1, 2], after=[2, 3])
+    assert diff.added == {3}
+    assert diff.removed == {1}
+    assert diff.is_changed is True
+
+
+@dataclass
+class _Obj:
+    key: str
+    value: int
+
+
+def test_index_list_lookup_by_attr_and_key():
+    objects = iterator.IndexList([_Obj(key="a", value=1), _Obj(key="b", value=2)])
+    assert objects.key["a"].value == 1
+
+    dicts = iterator.IndexList([{"id": "x", "value": 1}, {"id": "y", "value": 2}])
+    assert dicts.id["y"]["value"] == 2

corio-2.2.4/corio/tests/test_jsn.py

@@ -0,0 +1,24 @@
+from corio import jsn
+from corio.path import Path
+from corio.tests.helpers import SERIALIZATION_DATA
+
+
+def test_json():
+    """
+
+    Simple YAML round trip test
+
+    """
+    expected = SERIALIZATION_DATA
+    actual = jsn.from_json(jsn.to_json(expected))
+    assert actual == expected
+
+
+def test_json_path_round_trip(tmp_path):
+    expected = SERIALIZATION_DATA
+    path_json = Path(tmp_path / "serialization_test.json")
+
+    path_json.write_json(expected)
+    actual = path_json.read_json()
+
+    assert actual == expected

corio-2.2.4/corio/tests/test_name.py

@@ -0,0 +1,20 @@
+import random
+
+from corio import name
+
+
+def test_name_lists_are_non_empty():
+    assert len(name.get_left()) > 0
+    assert len(name.get_right()) > 0
+
+
+def test_get_name_tuple_or_string():
+    random.seed(0)
+    left_right = name.get(sep=None)
+    assert isinstance(left_right, tuple)
+    assert len(left_right) == 2
+
+    random.seed(0)
+    text = name.get(sep="-")
+    assert isinstance(text, str)
+    assert "-" in text