aec-agent-core 1.0.0.dev0__py3-none-any.whl

aec_agent_core/__init__.py

@@ -0,0 +1,166 @@
+"""aec-agent-core: what document agents run below their chat pages.
+
+1.0.0.dev0 is the empty package of the app split's step 10 (BACKLOG INF-32;
+``module_work/APP_SPLIT_PLAN.md``). It holds one thing, the alias helper
+step 11 uses when it moves a module in here, so the module's old import
+path keeps working until step 16 takes the aliases out:
+
+    # in the old package's __init__.py, e.g. funhouse_agent/__init__.py
+    from aec_agent_core import install_aliases
+    install_aliases({"funhouse_agent.vision_tools": "aec_agent_core.vision_tools"})
+
+From then on ``import funhouse_agent.vision_tools`` (or ``from
+funhouse_agent import vision_tools``) gives the very module object that
+``aec_agent_core.vision_tools`` is, with no stub file left at the old path.
+So git follows the move as a rename, and a test that patches by the old
+name (``monkeypatch.setattr("funhouse_agent.vision_tools.x", ...)``)
+patches the real module, which a re-exporting stub would silently not do.
+
+An alias also covers what lies under the name: with the table above,
+``funhouse_agent.vision_tools.sub`` is ``aec_agent_core.vision_tools.sub``.
+
+The alias is LAZY: nothing is imported until the old name is looked up (an
+import, or ``importlib.util.find_spec``, which imports the target). The module
+keeps its own ``__name__``, ``__spec__`` and ``__file__`` (the new ones).
+"""
+
+from __future__ import annotations
+
+import importlib
+import importlib.abc
+import importlib.machinery
+import sys
+import threading
+from typing import Mapping
+
+__version__ = "1.0.0.dev0"
+
+__all__ = ["install_aliases", "remove_aliases", "aliases", "resolve_alias",
+           "__version__"]
+
+_LOCK = threading.Lock()
+#: old dotted name -> new dotted name, for every installed alias.
+_TABLE: dict[str, str] = {}
+
+
+def _valid_name(name: object) -> bool:
+    return (isinstance(name, str) and bool(name)
+            and all(part.isidentifier() for part in name.split(".")))
+
+
+def resolve_alias(fullname: str) -> str | None:
+    """The new name an old dotted name stands for, or None if none does.
+
+    The longest matching alias wins, so ``a.b`` -> ``x`` and ``a.b.c`` ->
+    ``y`` send ``a.b.c.d`` to ``y.d``.
+    """
+    with _LOCK:
+        table = dict(_TABLE)
+    name = fullname
+    rest: list[str] = []
+    while name:
+        new = table.get(name)
+        if new is not None:
+            return ".".join([new, *reversed(rest)])
+        name, _, last = name.rpartition(".")
+        rest.append(last)
+    return None
+
+
+class _AliasLoader(importlib.abc.Loader):
+    """Hands the import system the already-imported real module."""
+
+    def __init__(self, target: str):
+        self._target = target
+
+    def create_module(self, spec):
+        return importlib.import_module(self._target)
+
+    def exec_module(self, module):
+        # The import system has just set module.__spec__ to the ALIAS spec
+        # (it always does, even on an existing module); put the module's own
+        # back, so reload, pickle by reference and find_spec see the real
+        # module. Nothing else on the module was overwritten: __name__,
+        # __loader__, __package__ and __file__ were already set.
+        spec = _REAL_SPECS.get(self._target)
+        if spec is not None and module is sys.modules.get(self._target):
+            module.__spec__ = spec
+
+
+#: The real spec of every module an alias handed out, kept before the import
+#: system overwrote it (see _AliasLoader.exec_module).
+_REAL_SPECS: dict[str, object] = {}
+
+
+class _AliasFinder(importlib.abc.MetaPathFinder):
+    """Finds an old (aliased) name and answers with the new module."""
+
+    def find_spec(self, fullname, path=None, target=None):
+        new = resolve_alias(fullname)
+        if new is None or new == fullname:
+            return None
+        module = importlib.import_module(new)
+        _REAL_SPECS.setdefault(new, module.__spec__)
+        is_pkg = hasattr(module, "__path__")
+        return importlib.machinery.ModuleSpec(
+            fullname, _AliasLoader(new), is_package=is_pkg)
+
+
+_FINDER = _AliasFinder()
+
+
+def _ensure_finder() -> None:
+    # First in line, so a stale file left at an old path cannot shadow the
+    # moved module.
+    if _FINDER not in sys.meta_path:
+        sys.meta_path.insert(0, _FINDER)
+
+
+def install_aliases(table: Mapping[str, str]) -> None:
+    """Make each old dotted name import as the module of its new name.
+
+    ``table`` maps old name -> new name, both full dotted module names.
+    Installing the same pair twice is harmless; pointing an old name at a
+    different new name, aliasing a name to itself, or aliasing a name that
+    is already imported as a DIFFERENT module raises ``ValueError``, because
+    each would leave two copies of the code or an alias that never applies.
+    """
+    pairs = dict(table)
+    for old, new in pairs.items():
+        if not (_valid_name(old) and _valid_name(new)):
+            raise ValueError(f"not a dotted module name: {old!r} -> {new!r}")
+        if old == new or new.startswith(old + ".") or old.startswith(new + "."):
+            raise ValueError(f"an alias cannot point into itself: {old} -> {new}")
+    with _LOCK:
+        for old, new in pairs.items():
+            have = _TABLE.get(old)
+            if have is not None and have != new:
+                raise ValueError(
+                    f"{old} is already an alias of {have}, not {new}")
+            loaded = sys.modules.get(old)
+            if loaded is not None and loaded is not sys.modules.get(new):
+                raise ValueError(
+                    f"{old} is already imported as its own module; an alias "
+                    f"to {new} would leave two copies")
+        _TABLE.update(pairs)
+        _ensure_finder()
+
+
+def remove_aliases(*olds: str) -> None:
+    """Take aliases out (all of them when no name is given).
+
+    A module already imported by an old name stays in ``sys.modules`` under
+    it; this only stops new imports from resolving. For tests, and for
+    step 16.
+    """
+    with _LOCK:
+        for old in (olds or tuple(_TABLE)):
+            _TABLE.pop(old, None)
+        if not _TABLE and _FINDER in sys.meta_path:
+            sys.meta_path.remove(_FINDER)
+
+
+def aliases() -> dict[str, str]:
+    """A copy of the installed aliases, old name -> new name."""
+    with _LOCK:
+        return dict(_TABLE)

aec_agent_core-1.0.0.dev0.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: aec-agent-core
+Version: 1.0.0.dev0
+Summary: The shared core of LLM agents that review and produce architecture, engineering and construction documents: model connections, vision calls, guards and records, Word and Excel, and a figure helper. No user interface of its own.
+Author-email: Sean O'Connell <soconnell345@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/soconnell345-geotech/GeotechStaffEngineer
+Project-URL: Repository, https://github.com/soconnell345-geotech/GeotechStaffEngineer
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.26
+Requires-Dist: scipy>=1.13
+Requires-Dist: deepagents<0.7.25,>=0.6.8
+Requires-Dist: langchain<1.4.6,>=1.3
+Requires-Dist: langgraph<1.3,>=1.2
+Requires-Dist: typing_extensions>=4.13
+Requires-Dist: openai<3.29.1
+Requires-Dist: langchain-openai>=1.3
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: plotly>=5
+Requires-Dist: python-docx>=1.1
+Requires-Dist: markdown-it-py>=3
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: planlens>=0.14
+Provides-Extra: anthropic
+Requires-Dist: langchain-anthropic>=1.4; extra == "anthropic"
+Dynamic: license-file
+
+# aec-agent-core
+
+The shared core of LLM agents that review and produce architecture,
+engineering and construction (AEC) documents. It holds what an agent runs
+below its chat page: the model connections, the vision calls and the file
+tools beside them, the figure helper with its plotting box, the agent's
+guards, limits and kept work, Word and Excel in and out, the run record and
+its checks, and the switches. It has no user interface of its own.
+
+Two applications are built on it:
+
+- **GeotechStaffEngineer** (`pip install geotech-staff-engineer`), the
+  geotechnical engineering agent, which pins this package exactly;
+- a document review application.
+
+## Status
+
+**1.0.0.dev0: an empty package.** It exists so that its build, its tests and
+the applications' pins on it can be checked before any code moves in. The
+only thing in it today is `aec_agent_core.install_aliases`, which lets a
+module keep answering to its old import path after it moves here, as the
+same module object (so an import or a test patch by either name reaches the
+one copy of the code).
+
+It is not yet published; GeotechStaffEngineer installs it from its own
+repository (`pip install -e packages/aec-agent-core`) until it is.
+
+## Install
+
+```
+pip install aec-agent-core              # once published
+pip install "aec-agent-core[anthropic]" # with Claude through LangChain
+```
+
+## Licence
+
+MIT, as GeotechStaffEngineer. See `LICENSE`.

aec_agent_core-1.0.0.dev0.dist-info/RECORD

@@ -0,0 +1,6 @@
+aec_agent_core/__init__.py,sha256=UD8OKewavWa9LjQsZDexoujf0bK84bYmJbBQk9PKFGc,6288
+aec_agent_core-1.0.0.dev0.dist-info/licenses/LICENSE,sha256=tUQ30KFGkSexrpVCJHr-ZBiREZfviUU6-IfDS0msr8g,1076
+aec_agent_core-1.0.0.dev0.dist-info/METADATA,sha256=zWi5slgJeR4jUh8HBJsa6_w7pLJZbNBykFJA-JhDOgI,3053
+aec_agent_core-1.0.0.dev0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+aec_agent_core-1.0.0.dev0.dist-info/top_level.txt,sha256=mc6IEpnX_M06db-9bQHx7Mtbp6yB02pdXRiDI5WMQU8,15
+aec_agent_core-1.0.0.dev0.dist-info/RECORD,,

aec_agent_core-1.0.0.dev0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aec_agent_core-1.0.0.dev0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 Sean O'Connell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aec_agent_core-1.0.0.dev0.dist-info/top_level.txt

@@ -0,0 +1 @@
+aec_agent_core