speclogician 0.0.0b1__py3-none-any.whl → 0.0.0.dev1__py3-none-any.whl

speclogician/data/container.py

@@ -1,402 +1,36 @@
 #
 #   Imandra Inc.
 #
-#   speclogician/data/container.py
+#   container.py
 #
 
-from typing import Any
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 from .traces import TestTrace, LogTrace
 from .refs import DocRef, SrcCodeRef
-from .mapping import ArtifactMap
-
-from ..utils import IMLValidity
-
-class SmartFindResults(BaseModel):
-    """Helper for returning search results"""
-    needle: str
-
-    test_traces: list[TestTrace] = Field(default_factory=list[TestTrace])
-    log_traces: list[LogTrace] = Field(default_factory=list[LogTrace])
-    doc_refs: list[DocRef] = Field(default_factory=list[DocRef])
-    src_code_refs: list[SrcCodeRef] = Field(default_factory=list[SrcCodeRef])
-
-    def empty(self) -> bool:
-        return not (self.test_traces or self.log_traces or self.doc_refs or self.src_code_refs)
 
+class ArtifactSummaryInfo(BaseModel):
+    """ """
+    pass
 
 class ArtifactContainer(BaseModel):
-    """Artifact container"""
-
-    test_traces: list[TestTrace] = Field(default_factory=list[TestTrace])
-    log_traces: list[LogTrace] = Field(default_factory=list[LogTrace])
-    doc_ref: list[DocRef] = Field(default_factory=list[DocRef])
-    src_code: list[SrcCodeRef] = Field(default_factory=list[SrcCodeRef])
-
-    num_test_traces_total: int = 0
-    num_test_traces_matched: int = 0
-    num_test_traces_logic_good: int = 0
-
-    num_log_traces_total: int = 0
-    num_log_traces_matched: int = 0
-    num_log_traces_logic_good: int = 0
-
-    num_src_code_arts_matched: int = 0
-    num_src_code_arts_total: int = 0
-
-    num_doc_arts_matched: int = 0
-    num_doc_arts_total: int = 0
-
-    # ----------------------------
-    # Internals
-    # ----------------------------
-
-    def _all_art_ids(self) -> set[str]:
-        ids: set[str] = set()
-        for xs in (self.test_traces, self.log_traces, self.doc_ref, self.src_code):
-            for a in xs:
-                if a.art_id is not None:
-                    ids.add(a.art_id)
-        return ids
-
-    def _ensure_unique_art_id(self, art_id: str) -> None:
-        if art_id in self._all_art_ids():
-            raise ValueError(f"Artifact with art_id='{art_id}' already exists in container")
-
-    def refresh_stats(self, art_map:ArtifactMap|None=None) -> None:
-        # Totals
-        self.num_test_traces_total = len(self.test_traces)
-        self.num_log_traces_total = len(self.log_traces)
-        self.num_src_code_arts_total = len(self.src_code)
-        self.num_doc_arts_total = len(self.doc_ref)
-
-        # Matched (best effort; 0 unless artifacts have a matched flag)
-        if art_map is not None:
-            def _is_linked(art_id: str | None) -> bool:
-                if not art_id:
-                    return False
-                return len(art_map.get_comp_for_artifact(art_id)) > 0
-
-            self.num_test_traces_matched = sum(1 for t in self.test_traces if _is_linked(t.art_id))
-            self.num_log_traces_matched = sum(1 for t in self.log_traces if _is_linked(t.art_id))
-            self.num_src_code_arts_matched = sum(1 for a in self.src_code if _is_linked(a.art_id))
-            self.num_doc_arts_matched = sum(1 for a in self.doc_ref if _is_linked(a.art_id))
-
-        # Logic good: count VALID IML traces
-        self.num_test_traces_logic_good = sum(
-            1
-            for t in self.test_traces
-            if getattr(getattr(t, "iml_validity", None), "iml_valid", IMLValidity.UNKNOWN) == IMLValidity.VALID
-        )
-        self.num_log_traces_logic_good = sum(
-            1
-            for t in self.log_traces
-            if getattr(getattr(t, "iml_validity", None), "iml_valid", IMLValidity.UNKNOWN) == IMLValidity.VALID
-        )
-
-    # ----------------------------
-    # Traces
-    # ----------------------------
-
-    def add_trace(self, trace: TestTrace | LogTrace) -> None:
-        """Add a trace (TestTrace or LogTrace). Uniqueness is by art_id only."""
-        if trace.art_id is None:
-            raise ValueError("Provided art_id is None")
-        self._ensure_unique_art_id(trace.art_id)
-
-        if isinstance(trace, TestTrace):
-            self.test_traces.append(trace)
-        elif isinstance(trace, LogTrace):
-            self.log_traces.append(trace)
-        else:
-            raise TypeError(f"Unsupported trace type: {type(trace).__name__}")
-
-        self.refresh_stats()
-
-    def rem_trace(self, art_id: str) -> None:
-        """Remove exactly one trace by art_id."""
-        before = len(self.test_traces)
-        self.test_traces = [t for t in self.test_traces if t.art_id != art_id]
-        if len(self.test_traces) != before:
-            self.refresh_stats()
-            return
-
-        before = len(self.log_traces)
-        self.log_traces = [t for t in self.log_traces if t.art_id != art_id]
-        if len(self.log_traces) != before:
-            self.refresh_stats()
-            return
-
-        raise ValueError(f"Trace not found (art_id='{art_id}')")
-
-    def edit_trace(self, art_id: str, patch: dict[str, object]) -> None:
-        """
-        Patch-edit a trace by art_id (Pydantic model_copy(update=...)).
-        """
-        for i, t in enumerate(self.test_traces):
-            if t.art_id == art_id:
-                self.test_traces[i] = t.model_copy(update=patch)
-                self.refresh_stats()
-                return
-
-        for i, t in enumerate(self.log_traces):
-            if t.art_id == art_id:
-                self.log_traces[i] = t.model_copy(update=patch)
-                self.refresh_stats()
-                return
-
-        raise ValueError(f"Trace not found (art_id='{art_id}')")
-
-    # ----------------------------
-    # Data artifacts
-    # ----------------------------
-
-    def add_data_art(self, art: DocRef | SrcCodeRef) -> None:
-        """Add a data artifact (DocRef or SrcCodeRef)."""
-        if art.art_id is None:
-            raise ValueError("Provided art_id is None")
-        self._ensure_unique_art_id(art.art_id)
-
-        if isinstance(art, DocRef):
-            self.doc_ref.append(art)
-        elif isinstance(art, SrcCodeRef):
-            self.src_code.append(art)
-        else:
-            raise TypeError(f"Unsupported data artifact type: {type(art).__name__}")
+    """ 
+    Artifact container
+    """
 
-        self.refresh_stats()
+    test_traces : list[TestTrace] = []
+    log_traces : list[LogTrace] = []
+    doc_ref : list[DocRef] = []
+    src_code : list[SrcCodeRef] = []
 
-    def rem_data_art(self, art_id: str) -> None:
-        """Remove exactly one data artifact by art_id."""
-        before = len(self.doc_ref)
-        self.doc_ref = [a for a in self.doc_ref if a.art_id != art_id]
-        if len(self.doc_ref) != before:
-            self.refresh_stats()
-            return
 
-        before = len(self.src_code)
-        self.src_code = [a for a in self.src_code if a.art_id != art_id]
-        if len(self.src_code) != before:
-            self.refresh_stats()
-            return
-
-        raise ValueError(f"Data artifact not found (art_id='{art_id}')")
-
-    def edit_data_art(self, art_id: str, patch: dict[str, object]) -> None:
-        """Patch-edit a data artifact by art_id."""
-        for i, a in enumerate(self.doc_ref):
-            if a.art_id == art_id:
-                self.doc_ref[i] = a.model_copy(update=patch)
-                self.refresh_stats()
-                return
-
-        for i, a in enumerate(self.src_code):
-            if a.art_id == art_id:
-                self.src_code[i] = a.model_copy(update=patch)
-                self.refresh_stats()
-                return
-
-        raise ValueError(f"Data artifact not found (art_id='{art_id}')")
-
-    # ----------------------------
-    # Iterators / basic accessors
-    # ----------------------------
-
-    def all_traces(self) -> list[TestTrace | LogTrace]:
-        return list(self.test_traces) + list(self.log_traces)
-
-    def all_data_arts(self) -> list[DocRef | SrcCodeRef]:
-        return list(self.doc_ref) + list(self.src_code)
-
-    def get_by_art_id(self, art_id: str) -> TestTrace | LogTrace | DocRef | SrcCodeRef | None:
-        for a in self.test_traces:
-            if a.art_id == art_id:
-                return a
-        for a in self.log_traces:
-            if a.art_id == art_id:
-                return a
-        for a in self.doc_ref:
-            if a.art_id == art_id:
-                return a
-        for a in self.src_code:
-            if a.art_id == art_id:
-                return a
-        return None
-
-
-    # ----------------------------
-    # TestTrace lookups
-    # ----------------------------
-
-    def find_test_traces_by_name(self, name: str) -> list[TestTrace]:
-        # NOT unique by design
-        return [t for t in self.test_traces if t.name == name]
-
-    def find_test_traces_by_filepath(self, filepath: str) -> list[TestTrace]:
-        return [t for t in self.test_traces if t.filepath == filepath]
-
-    def find_test_traces_by_language(self, language: str) -> list[TestTrace]:
-        return [t for t in self.test_traces if (t.language or "") == language]
-
-    def search_test_traces_text(self, needle: str) -> list[TestTrace]:
-        n = needle.lower()
-        out: list[TestTrace] = []
-        for t in self.test_traces:
-            hay = " ".join(
-                [
-                    t.name or "",
-                    t.filepath or "",
-                    t.language or "",
-                    t.contents or "",
-                ]
-            ).lower()
-            if n in hay:
-                out.append(t)
-        return out
-
-
-    # ----------------------------
-    # LogTrace lookups
-    # ----------------------------
-
-    def find_log_traces_by_filename(self, filename: str) -> list[LogTrace]:
-        # NOT unique by design
-        return [t for t in self.log_traces if t.filename == filename]
-
-    def search_log_traces_text(self, needle: str) -> list[LogTrace]:
-        n = needle.lower()
-        out: list[LogTrace] = []
-        for t in self.log_traces:
-            hay = " ".join([t.filename or "", t.contents or ""]).lower()
-            if n in hay:
-                out.append(t)
-        return out
-
-
-    # ----------------------------
-    # Data artifact lookups
-    # ----------------------------
-
-    def find_doc_refs_containing(self, needle: str) -> list[DocRef]:
-        n = needle.lower()
-        return [
-            d
-            for d in self.doc_ref
-            if n in (d.text or "").lower() or n in ((d.meta or "").lower())
-        ]
-
-    def find_src_code_by_file_path(self, file_path: str) -> list[SrcCodeRef]:
-        return [s for s in self.src_code if (s.file_path or "") == file_path]
-
-    def find_src_code_by_language(self, language: str) -> list[SrcCodeRef]:
-        return [s for s in self.src_code if (s.language or "") == language]
-
-    def search_src_code_text(self, needle: str) -> list[SrcCodeRef]:
-        n = needle.lower()
-        out: list[SrcCodeRef] = []
-        for s in self.src_code:
-            hay = " ".join(
-                [
-                    s.file_path or "",
-                    s.language or "",
-                    s.src_code or "",
-                    s.iml_code or "",
-                    s.meta or "",
-                ]
-            ).lower()
-            if n in hay:
-                out.append(s)
-        return out
-
-    def smart_find(
-        self,
-        needle: str,
-        *,
-        include: set[str] | None = None,
-        max_per_type: int | None = 50,
-    ) -> SmartFindResults:
+    def info(self):
         """
-        Search across *all* artifacts with a single entrypoint.
-
-        - `include`: optional subset of {"test", "log", "doc", "src"}; default = all.
-        - `max_per_type`: cap results per type (None = unlimited).
         """
-        inc = include or {"test", "log", "doc", "src"}
-        n = (needle or "").lower()
-
-        def _cap(xs: list[Any]) -> list[Any]:
-            if max_per_type is None:
-                return xs
-            return xs[:max_per_type]
-
-        out = SmartFindResults(needle=needle)
-
-        if "test" in inc:
-            hits: list[TestTrace] = []
-            for t in self.test_traces:
-                hay = " ".join(
-                    [
-                        t.art_id or "",
-                        t.name or "",
-                        t.filepath or "",
-                        t.language or "",
-                        t.contents or "",
-                        t.given or "",
-                        t.when or "",
-                        t.then or "",
-                    ]
-                ).lower()
-                if n in hay:
-                    hits.append(t)
-            out.test_traces = _cap(hits)
-
-        if "log" in inc:
-            hits: list[LogTrace] = []
-            for t in self.log_traces:
-                hay = " ".join(
-                    [
-                        t.art_id or "",
-                        t.filename or "",
-                        t.contents or "",
-                        t.given or "",
-                        t.when or "",
-                        t.then or "",
-                    ]
-                ).lower()
-                if n in hay:
-                    hits.append(t)
-            out.log_traces = _cap(hits)
-
-        if "doc" in inc:
-            hits: list[DocRef] = []
-            for d in self.doc_ref:
-                hay = " ".join(
-                    [
-                        d.art_id or "",
-                        d.text or "",
-                        d.meta or "",
-                    ]
-                ).lower()
-                if n in hay:
-                    hits.append(d)
-            out.doc_refs = _cap(hits)
 
-        if "src" in inc:
-            hits: list[SrcCodeRef] = []
-            for s in self.src_code:
-                hay = " ".join(
-                    [
-                        s.art_id or "",
-                        s.file_path or "",
-                        s.language or "",
-                        s.src_code or "",
-                        s.iml_code or "",
-                        s.meta or "",
-                    ]
-                ).lower()
-                if n in hay:
-                    hits.append(s)
-            out.src_code_refs = _cap(hits)
+        return {'hello': 123}
 
-        return out
+    def add(self):
+        """ """
+        pass
+    

speclogician/data/mapping.py

@@ -1,10 +1,11 @@
 #
 #   Imandra Inc.
 #
-#   speclogician/data/mapping.py
+#   mapping.py
 #
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
+from typing import Dict
 
 from enum import StrEnum
 
@@ -18,39 +19,39 @@ class ArtifactMap(BaseModel):
     handle potentially large datasets (e.g. massive logs)
     """
 
-    art_to_comp_map: dict[str, list[str]] = Field(default_factory=dict)
-    comp_to_art_map: dict[str, list[str]] = Field(default_factory=dict)
+    art_to_comp_map : Dict[str, list[str]] = {}
+    comp_to_art_map : Dict[str, list[str]] = {}
 
-    def add_connection (self, art_id : str, comp_name : str):
+    def add_connection (self, art_id : str, comp_id : str):
         """
         Add a link between artifact and model component
         """
         if art_id not in self.art_to_comp_map:
             self.art_to_comp_map[art_id] = []
         
-        if comp_name not in self.art_to_comp_map[art_id]:
-            self.art_to_comp_map[art_id].append(comp_name)
+        if comp_id not in self.art_to_comp_map[art_id]:
+            self.art_to_comp_map[art_id].append(comp_id)
 
-        if comp_name not in self.comp_to_art_map:
-            self.comp_to_art_map[comp_name] = []
+        if comp_id not in self.comp_to_art_map:
+            self.comp_to_art_map[comp_id] = []
         
-        if art_id not in self.comp_to_art_map[comp_name]:
-            self.comp_to_art_map[comp_name].append(art_id)        
+        if art_id not in self.comp_to_art_map[comp_id]:
+            self.comp_to_art_map[comp_id].append(art_id)        
 
-    def rem_connection (self, artifact_id : str, comp_name : str):
+    def rem_connection (self, artifact_id : str, comp_id : str):
         """
         Remove a connection
         """
 
         if artifact_id in self.art_to_comp_map:
-            if comp_name in self.art_to_comp_map[artifact_id]:
-                self.art_to_comp_map[artifact_id].remove(comp_name)
+            if comp_id in self.art_to_comp_map[artifact_id]:
+                self.art_to_comp_map[artifact_id].remove(comp_id)
         else:
             return False
 
-        if comp_name in self.comp_to_art_map:
-            if artifact_id in self.comp_to_art_map[comp_name]:
-                self.comp_to_art_map[comp_name].remove(artifact_id)
+        if comp_id in self.comp_to_art_map:
+            if artifact_id in self.comp_to_art_map[comp_id]:
+                self.comp_to_art_map[comp_id].remove(artifact_id)
     
     def rem_element (self, elem_type : ElementType, str_id : str):
         """

speclogician/data/refs.py

@@ -1,24 +1,25 @@
 #
 #   Imandra Inc.
 #
-#   speclogician/data/refs.py
+#   refs.py
 #
 
-from .artifact import DataArtifact
+from .artifact import Artifact
 
-class DocRef(DataArtifact):
+class DocRef(Artifact):
     """
     Documentation reference
     """
-    text : str # Actual documentation text
-    meta : str | None = None # Any additional information
+    meta : str
+    text : str
     
-class SrcCodeRef(DataArtifact):
+class SrcCodeRef(Artifact):
     """
     Source code reference
     """
-    src_code : str # The original source code
-    language : str | None  = None # Programming language of the source code
-    file_path : str | None = None # File path of the source file
-    iml_code : str | None = None # Formalized version of the source code in IML
-    meta : str | None = None # Any additional information about the source code reference
+    
+    meta : str #
+    language : str #
+    file_path : str #
+    src_code : str #
+    iml_code : str # 

speclogician/data/reports.py

@@ -0,0 +1,11 @@
+#
+#   Imandra Inc.
+#
+#   reports.py
+#
+
+from pydantic import BaseModel
+
+
+class TestFormalization(BaseModel):
+    pass

speclogician/data/traces.py

@@ -1,7 +1,7 @@
 #
 #   Imandra Inc.
 #
-#   speclogician/data/trace.py
+#   trace.py
 #
 
 from .artifact import TraceArtifact
@@ -10,12 +10,14 @@ class TestTrace (TraceArtifact):
     """
     Test trace formalization
     """    
-    __test__ = False # this will let pytest know it's not something we should attempt to test
 
     name : str # Test case name
-    filepath : str = "" # Original test filepath
-    language : str | None = None # Language of the original source code
-    contents : str | None = None # Original test contents
+    filepath : str # Original test filepath
+    language : str # Language of the original source code
+    contents : str # Original test contents
+    time : str # Time when this done
+
+    # Contain 
 
 class LogTrace(TraceArtifact):
     """
@@ -23,4 +25,11 @@ class LogTrace(TraceArtifact):
     """
 
     filename : str # 
-    contents : str  # Contents of the log entry
+    contents : str # Contents of the log entry
+
+    # Formalized entry
+    given : str
+    when : str
+    then : str
+
+    

speclogician/llms/llmtools.py

@@ -0,0 +1,102 @@
+#
+#   Imandra Inc.
+#
+#   llmtools.py
+#
+
+import datetime, os, dotenv, sys, yaml, typer
+from typing import Optional
+from pathlib import Path
+from ..data.reports import TestFormalization
+from llms.overlay import Overlay
+
+#from langchain_anthropic import ChatAnthropic
+dotenv.load_dotenv("../.env")
+
+llm = None 
+
+#ChatAnthropic (
+#    model_name="claude-sonnet-4-20250514",
+#    api_key=os.environ["ANTHROPIC_API_KEY"],
+#)
+
+
+def test_formalizer (
+        filepath : str,
+        overlay : Overlay,
+        domain_model : Optional[str] = "N/A",
+        ) -> TestFormalization:
+    """
+    Returns a tuple of the logic and the type model
+    """
+    
+    test_case = Path(filepath).read_text()
+    try:
+        generic_prompt = Path("../prompts/generic.md").read_text()
+    except Exception as e:
+        print(f"Failed to load in the generic prompt: {e}")
+        sys.exit(0)
+
+    prompt = f"""
+{generic_prompt}
+
+{overlay}
+
+Domain model:
+----
+{domain_model}
+----
+
+Test case:
+----
+{test_case}
+----
+"""
+
+    structured_model = llm.with_structured_output(FormalizationResponse)
+
+    # Let's call the LLM
+    try: 
+        response : FormalizationResponse = structured_model.invoke(prompt)
+    except Exception as e:
+        typer.secho(f"Failed to make the LLM call: {e}", err=True)
+        sys.exit(0)
+
+    tf = TestFormalization(
+        name = response.test_name_str,
+        language = overlay.language,
+        filepath = filepath,
+        contents = test_case,
+        time = str(datetime.datetime.now()),
+        scenarios = response.scenarios,
+        domain_model = response.domain_model,
+    )
+
+    return tf
+
+def retry_test_formalization (
+        tf : TestFormalization,
+        model_response : str,
+    ) -> TestFormalization:
+    """
+    Make the call again to 
+    """
+
+    return tf
+
+if __name__ == "__main__":
+
+    base_dir = "../data/gherkin"
+    paths = os.listdir(base_dir)
+    overlay = Overlay.from_file("../overlays/gherkin.yaml")
+    domain_model : str = "N/A"
+    
+    responses : list[LLMResponse] = []
+
+    for path in paths:
+        r = test_formalizer(os.path.join(base_dir, paths[0]), overlay, domain_model)
+        responses.append(r)
+        domain_model = r.domain_model
+
+    for r in responses:
+        print (yaml.dump(r, default_flow_style=False))