tensorcode 0.1.0a1__py3-none-any.whl

tensorcode/temporal.py

@@ -0,0 +1,189 @@
+"""Event time and ordering, so tense stops being a label and starts being a question.
+
+The grammar reads tense and aspect and puts them in a feature; the projection then drops
+them. So "the grain arrived" and "the grain will arrive" become the same claim, and
+"what did you do before that" has nothing to stand on. Here a parsed tense becomes an
+:class:`~tensorcode.records.Interval` on the claim, and events get times that can be
+ordered, so the graph answers *when* and *in what order*.
+
+Two clocks are kept apart, because conflating them is how a record of what was said
+becomes a record of what happened:
+
+* ``observed_at`` on evidence: when a source said it. Already in the store.
+* the event's own time: when the thing happened. That is what this module adds.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from typing import Any, Iterable, Mapping, Sequence
+
+from .outcomes import Unknown
+from .records import Claim, ClaimRecord, Evidence, Interval, Ref, Store
+
+#: how a connective relates the clause it introduces to the main clause
+CONNECTIVES: dict[str, str] = {
+    "before": "before", "after": "after", "since": "after", "until": "before",
+    "while": "during", "when": "during", "whenever": "during", "once": "after",
+    "then": "after", "earlier": "before", "later": "after", "meanwhile": "during",
+}
+
+AT = "happened_at"
+ENDED = "ended_at"
+
+
+def interval_for(features: Mapping[str, Any], now: datetime) -> Interval:
+    """The interval a tense/aspect commits to, relative to ``now``.
+
+    Deliberately coarse: past means "ended before now", future means "starts after now",
+    present means "holds now". A coarse interval that is true beats a precise one invented.
+    """
+    tense, aspect = features.get("tense"), features.get("aspect")
+    if tense == "past":
+        return Interval(None, now) if aspect != "perfect" else Interval(None, now)
+    if tense == "future":
+        return Interval(now, None)
+    if tense == "present":
+        return Interval(now, now) if aspect != "progressive" else Interval(now, None)
+    return Interval()
+
+
+@dataclass(frozen=True)
+class Event:
+    ref: Ref
+    at: datetime
+    kind: str | None = None
+
+    def describe(self) -> str:
+        return f"{self.ref.id}{f' ({self.kind})' if self.kind else ''} at {self.at.isoformat(timespec='seconds')}"
+
+
+def tell_event(mind: Store, ref: Ref, *, at: datetime, kind: str | None = None, source: Ref,
+               ended: datetime | None = None, method: str = "temporal") -> Ref:
+    """Record when an event happened (as distinct from when it was reported)."""
+    evidence = Evidence(source=source, observed_at=datetime.now(timezone.utc), method=method)
+    mind.tell(Claim(ref, AT, at, valid=Interval(at, ended or at)), evidence)
+    if kind:
+        mind.tell(Claim(ref, "is_a", kind, valid=Interval(at, ended or at)), evidence)
+    if ended:
+        mind.tell(Claim(ref, ENDED, ended, valid=Interval(at, ended)), evidence)
+    return ref
+
+
+def event_time(mind: Store, ref: Ref) -> datetime | Unknown:
+    """When an event happened, by its own clock; falls back to nothing, never to a guess."""
+    for record in mind.claims(ref, AT):
+        value = record.claim.object
+        if isinstance(value, datetime):
+            return value
+    return Unknown("no_event_time", f"{ref.id} has no recorded time of happening")
+
+
+def events(mind: Store, *, kind: str | None = None) -> list[Event]:
+    """Every event with a recorded time, earliest first."""
+    out: list[Event] = []
+    for record in mind.claims(predicate=AT):
+        value = record.claim.object
+        if not isinstance(value, datetime):
+            continue
+        ref = record.claim.subject
+        of = next((r.claim.object for r in mind.claims(ref, "is_a")), None)
+        if kind is not None and of != kind:
+            continue
+        out.append(Event(ref, value, of if isinstance(of, str) else None))
+    return sorted(out, key=lambda e: (e.at, e.ref.id))
+
+
+def relate(mind: Store, a: Ref, b: Ref, *, tolerance: timedelta = timedelta(0)) -> str | Unknown:
+    """'before', 'after' or 'simultaneous' — or a refusal when either time is unrecorded."""
+    ta, tb = event_time(mind, a), event_time(mind, b)
+    if isinstance(ta, Unknown):
+        return ta
+    if isinstance(tb, Unknown):
+        return tb
+    if abs(ta - tb) <= tolerance:
+        return "simultaneous"
+    return "before" if ta < tb else "after"
+
+
+def order(mind: Store, refs: Iterable[Ref]) -> tuple[list[Ref], list[Ref]]:
+    """Refs sorted by their event time, and the ones that have no time to sort by."""
+    timed: list[tuple[datetime, Ref]] = []
+    untimed: list[Ref] = []
+    for ref in refs:
+        at = event_time(mind, ref)
+        (untimed if isinstance(at, Unknown) else timed).append(ref if isinstance(at, Unknown) else (at, ref))  # type: ignore[arg-type]
+    return [ref for _, ref in sorted(timed, key=lambda pair: (pair[0], pair[1].id))], untimed
+
+
+def before(mind: Store, ref: Ref, *, kind: str | None = None) -> list[Event]:
+    """Events that happened before this one."""
+    at = event_time(mind, ref)
+    return [] if isinstance(at, Unknown) else [e for e in events(mind, kind=kind) if e.at < at and e.ref != ref]
+
+
+def after(mind: Store, ref: Ref, *, kind: str | None = None) -> list[Event]:
+    at = event_time(mind, ref)
+    return [] if isinstance(at, Unknown) else [e for e in events(mind, kind=kind) if e.at > at and e.ref != ref]
+
+
+def during(mind: Store, start: datetime, end: datetime, *, kind: str | None = None) -> list[Event]:
+    return [e for e in events(mind, kind=kind) if start <= e.at <= end]
+
+
+def first_seen(record: ClaimRecord) -> datetime | None:
+    """The earliest moment any source put this claim on record."""
+    times = [e.observed_at for e in record.evidence]
+    return min(times) if times else None
+
+
+def changed_since(mind: Store, when: datetime, *, scope: Ref | None = None) -> list[Claim]:
+    """Claims that came on record after ``when`` — what is new since a moment.
+
+    This reads the *reporting* clock, which is the right one for "what changed since my
+    last message": the question is about the record, not about when the world moved.
+    """
+    out: list[tuple[datetime, Claim]] = []
+    for record in mind.claims(scope=scope) if scope is not None else mind.claims():
+        seen = first_seen(record)
+        if seen is not None and seen > when:
+            out.append((seen, record.claim))
+    return [claim for _, claim in sorted(out, key=lambda pair: pair[0])]
+
+
+def since(mind: Store, ref: Ref, *, kind: str | None = None) -> list[Event] | Unknown:
+    """Events after a named event — "what happened since the commit"."""
+    at = event_time(mind, ref)
+    return at if isinstance(at, Unknown) else after(mind, ref, kind=kind)
+
+
+def connective_relation(word: str) -> str | Unknown:
+    """What ordering a connective asserts between its clause and the main one."""
+    got = CONNECTIVES.get(word.strip().lower())
+    return got if got else Unknown("not_a_temporal_connective", word)
+
+
+def tell_order(mind: Store, earlier: Ref, later: Ref, *, source: Ref, relation: str = "before",
+               method: str = "temporal:connective") -> Claim:
+    """Record an ordering asserted by language, when neither event has a clock time.
+
+    "the grain arrived before the snow came" orders two events without dating either, and
+    that is worth keeping: it answers ordering questions that timestamps cannot.
+    """
+    claim = Claim(earlier, relation, later)
+    mind.tell(claim, Evidence(source=source, observed_at=datetime.now(timezone.utc), method=method))
+    return claim
+
+
+def ordered_by_claims(mind: Store, a: Ref, b: Ref) -> str | Unknown:
+    """Ordering from asserted ``before``/``after`` claims, for undated events."""
+    if mind.claims(a, "before", b):
+        return "before"
+    if mind.claims(b, "before", a):
+        return "after"
+    if mind.claims(a, "after", b):
+        return "after"
+    if mind.claims(b, "after", a):
+        return "before"
+    return Unknown("no_recorded_order", f"nothing orders {a.id} and {b.id}")

tensorcode/wants.py

@@ -0,0 +1,185 @@
+"""Wants: an open question as a first-class object, and the standing pull toward answering it.
+
+``Unknown`` says an operation could not answer. That is where it stops, which is why a
+mind built on it goes quiet instead of going looking. A ``Want`` is the same admission with
+its consequences attached: what would satisfy it, what provenance the answer must have, and
+which candidate satisfiers exist — a memory to search, a modality to look at, a command to
+run, a person to ask, a derivation to attempt.
+
+The runtime can then rank wants by what an answer is worth against what it costs, and hand
+the chosen one to whoever can satisfy it. Abstention stays honest at both ends: looking up
+an answer refuses to pick between disagreeing claims, refuses hearsay where the want asked
+for an observation, and a want nothing can satisfy simply stays open.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass, field
+from typing import Any, Iterable, Literal
+
+from .outcomes import Score, Unknown
+from .records import ClaimRecord, Ref, Store
+
+SatisfierKind = Literal["memory", "perceive", "command", "ask", "derive"]
+
+#: which modalities count as first-hand, for a want that requires an observation
+FIRSTHAND = ("pixels", "structure", "text")
+
+
+@dataclass(frozen=True)
+class Satisfier:
+    """One way this want might be answered, with what it would cost to try."""
+
+    kind: SatisfierKind
+    detail: str  # a place to look, a command to run, a question to put to someone
+    cost: float = 1.0  # caller's own units (seconds, tokens, keystrokes)
+    odds: Score = field(default_factory=lambda: Score(0.5, "uncalibrated"))
+
+    @property
+    def worth(self) -> float:
+        return self.odds.value / max(self.cost, 1e-6)
+
+
+@dataclass(frozen=True)
+class Want:
+    """A question the mind is holding open."""
+
+    question: str
+    subject: Ref | None = None
+    predicate: str | None = None
+    expect: type | None = None  # what kind of value would satisfy it
+    requires: str | None = None  # provenance demand: "observed", "not-hearsay", or a modality name
+    satisfiers: tuple[Satisfier, ...] = ()
+    value: float = 1.0  # how much an answer is worth
+    asked_by: Ref | None = None  # who wants to know (the user, a rule, a procedure)
+
+    @property
+    def id(self) -> str:
+        key = f"{self.question}|{self.subject}|{self.predicate}|{self.requires}"
+        return "want:" + hashlib.sha256(key.encode()).hexdigest()[:12]
+
+    def best_satisfier(self) -> Satisfier | None:
+        return max(self.satisfiers, key=lambda s: (s.worth, s.kind), default=None)
+
+
+@dataclass(frozen=True)
+class Answer:
+    """A want satisfied, with the claims that answer it and how they were known."""
+
+    want_id: str
+    value: Any
+    claims: tuple[str, ...]
+    modality: tuple[str, ...] = ()
+
+    def __str__(self) -> str:
+        return f"{self.value!r} (from {len(self.claims)} claim{'s' * (len(self.claims) != 1)})"
+
+
+def want_from(unknown: Unknown, question: str, *, subject: Ref | None = None, predicate: str | None = None,
+              satisfiers: Iterable[Satisfier] = (), value: float = 1.0) -> Want:
+    """Turn a dead-end ``Unknown`` into a want, keeping its reason and any candidates it had."""
+    extra = tuple(Satisfier("derive", f"reconsider {cand!r}", cost=0.5, odds=score) for cand, score in unknown.candidates)
+    return Want(question=question, subject=subject, predicate=predicate,
+                satisfiers=tuple(satisfiers) + extra, value=value,
+                asked_by=Ref(f"unknown:{unknown.reason}"))
+
+
+class Wants:
+    """The standing set of open questions."""
+
+    def __init__(self) -> None:
+        self.open: dict[str, Want] = {}
+        self.answered: dict[str, Answer] = {}
+        self.abandoned: dict[str, str] = {}
+
+    def add(self, want: Want) -> str:
+        if want.id not in self.answered:
+            self.open[want.id] = want
+        return want.id
+
+    def drop(self, want_id: str, reason: str) -> None:
+        self.open.pop(want_id, None)
+        self.abandoned[want_id] = reason
+
+    def satisfied(self, want_id: str, answer: Answer) -> Answer:
+        self.open.pop(want_id, None)
+        self.answered[want_id] = answer
+        return answer
+
+    # -- ranking
+
+    def ranked(self) -> list[tuple[Want, Satisfier | None, float]]:
+        """Open wants by what answering them is worth against what it would cost."""
+        rows = []
+        for want in self.open.values():
+            best = want.best_satisfier()
+            rows.append((want, best, want.value * (best.worth if best else 0.0)))
+        return sorted(rows, key=lambda row: (-row[2], row[0].id))
+
+    def next_to_pursue(self) -> tuple[Want, Satisfier] | None:
+        for want, satisfier, _ in self.ranked():
+            if satisfier is not None:
+                return want, satisfier
+        return None
+
+    # -- answering from memory
+
+    def look_up(self, want: Want, mind: Store, *, frames: Any = None) -> Answer | Unknown:
+        """Try to answer from what the mind already holds. Refuses to guess."""
+        if want.subject is None and want.predicate is None:
+            return Unknown("want_underspecified", f"{want.question!r} names neither a subject nor a predicate")
+        records = mind.claims(subject=want.subject, predicate=want.predicate)
+        if not records:
+            return Unknown("not_in_memory", f"nothing recorded for {want.question!r}")
+        allowed = [r for r in records if _provenance_ok(r, want.requires, frames)]
+        if not allowed:
+            kinds = sorted({m for r in records for m in _modalities(r, frames)})
+            return Unknown("provenance_unmet", f"{want.question!r} needs {want.requires}; have only {', '.join(kinds) or 'unknown'}",
+                           candidates=tuple((r.claim.object, Score(0.5, "uncalibrated")) for r in records))
+        if want.expect is not None:
+            allowed = [r for r in allowed if isinstance(r.claim.object, want.expect)]
+            if not allowed:
+                return Unknown("wrong_type", f"{want.question!r} expects {want.expect.__name__}")
+        distinct = {repr(r.claim.object): r for r in allowed}
+        if len(distinct) > 1:
+            return Unknown("disagreement", f"memory holds {len(distinct)} different answers to {want.question!r}",
+                           candidates=tuple((r.claim.object, Score(1 / len(distinct), "vote_share")) for r in distinct.values()))
+        record = next(iter(distinct.values()))
+        return Answer(want.id, record.claim.object, tuple(sorted(r.id for r in allowed)), _modalities(record, frames))
+
+    def pursue_from_memory(self, mind: Store, *, frames: Any = None) -> list[Answer]:
+        """Answer every open want memory can already settle; leave the rest open."""
+        out = []
+        for want in list(self.open.values()):
+            found = self.look_up(want, mind, frames=frames)
+            if isinstance(found, Answer):
+                out.append(self.satisfied(want.id, found))
+        return out
+
+    def as_unknown(self, want: Want) -> Unknown:
+        """What to hand a caller that wanted an answer now: honest, with what we would try next."""
+        best = want.best_satisfier()
+        detail = f"{want.question}; next I would {best.kind} ({best.detail})" if best else f"{want.question}; nothing I can do would answer it"
+        return Unknown("open_want", detail)
+
+
+def _modalities(rec: ClaimRecord, frames: Any) -> tuple[str, ...]:
+    if frames is not None:
+        binding = frames.binding(rec.id)
+        if binding is not None:
+            return binding.modality
+    from .frames import modality_of
+
+    return modality_of(rec)
+
+
+def _provenance_ok(rec: ClaimRecord, requires: str | None, frames: Any) -> bool:
+    if requires is None:
+        return True
+    mods = _modalities(rec, frames)
+    if requires == "observed":
+        return any(m in FIRSTHAND for m in mods)
+    if requires == "not-hearsay":
+        return "hearsay" not in mods
+    return requires in mods

tensorcode-0.1.0a1.dist-info/METADATA

@@ -0,0 +1,196 @@
+Metadata-Version: 2.5
+Name: tensorcode
+Version: 0.1.0a1
+Summary: Typed cognitive operations with swappable implementations: rules, learned models, or general models, chosen by policy
+Project-URL: Homepage, https://github.com/TensaCo/tensacode-py
+Project-URL: Source, https://github.com/TensaCo/tensacode-py
+Project-URL: Issues, https://github.com/TensaCo/tensacode-py/issues
+Project-URL: Design, https://github.com/TensaCo/tensacode-py/tree/main/docs/revival
+Author-email: Jacob Valdez <jacob.valdez@tensaco.ai>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,cascade,cognitive-architecture,neurosymbolic,typed-operations
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: numpy>=1.26; extra == 'dev'
+Requires-Dist: pydantic>=2.5; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Provides-Extra: learned
+Requires-Dist: numpy>=1.26; extra == 'learned'
+Requires-Dist: scikit-learn>=1.5; extra == 'learned'
+Provides-Extra: learned-neural
+Requires-Dist: torch>=2.1; extra == 'learned-neural'
+Requires-Dist: transformers>=4.40; extra == 'learned-neural'
+Provides-Extra: local-model
+Requires-Dist: torch>=2.4; extra == 'local-model'
+Requires-Dist: transformers>=4.45; extra == 'local-model'
+Description-Content-Type: text/markdown
+
+# TensorCode
+
+**Typed cognitive operations with swappable implementations.** Your program says *what*
+it needs (parse this, classify that, choose an action under these constraints, check this
+claim). A policy decides *which* implementation answers: rules, a learned model, or a
+general model. Every answer is validated against the operation's type, every abstention
+is an explicit value, and every attempt is traced.
+
+> **Status: pre-alpha (0.1.0a1).** The API will change. The core has no third-party
+> dependencies. Nothing here calls a language model unless you bind one.
+
+```bash
+pip install --pre tensorcode
+```
+
+Python 3.11+.
+
+## Quick start
+
+```python
+import enum
+import tensorcode as tc
+from tensorcode.backends.builtin import KeywordClassifier
+
+class Intent(enum.Enum):
+    LOST_CARD = "lost_card"
+    REFUND = "refund"
+
+print(tc.classify("I lost my card", Intent))
+# Unknown(reason='no_implementation', ...)   <- nothing bound: an explicit Unknown, not a guess
+
+rules = KeywordClassifier(Intent, {
+    Intent.LOST_CARD: [r"\blost\b", r"\bstolen\b"],
+    Intent.REFUND: [r"\brefund\b"],
+})
+
+@tc.implementation("classify", name="fallback", version="1")
+def ask_a_human(request):
+    return tc.Unknown("needs_human", request.subject)
+
+with tc.use(tc.Runtime([rules, ask_a_human])) as rt:
+    print(tc.classify("I lost my card", Intent))       # Intent.LOST_CARD
+    print(tc.classify("where is my parcel?", Intent))  # Unknown(reason='needs_human', ...)
+    print(rt.trace.render())
+```
+
+```text
+classify -> Intent.LOST_CARD  [0.04 ms total, 0.01 ms backend]
+  - keyword-rules@1 answer
+classify -> {'unknown': 'needs_human', ...}  [0.03 ms total, 0.01 ms backend]
+  - keyword-rules@1 abstain: no_rule_matched
+  - fallback@1 abstain: needs_human, usd=? (unknown)
+```
+
+The program never names a backend. Swap the rules for a scikit-learn classifier or a local
+model by changing the `Runtime`, not the program.
+
+## Core ideas
+
+**Operations fix the meaning.** Each facade validates its output and fails closed:
+
+| Family | Operations |
+| --- | --- |
+| infer | `parse`, `classify`, `choose`, `rank` |
+| check | `check`, `verify` |
+| rewrite | `propose` (a `Patch`, inert until `Store.apply`) |
+| act | `invoke` (returns a `Receipt`), `Plan`, `run_plan` |
+| context | `pack`, `dedupe` |
+
+`classify` estimates what *is true*. `choose` selects what *to do*, under an `Objective`
+and hard `Constraint`s that TensorCode checks itself before any backend sees the options.
+
+**Outcome values keep distinctions a caller must not collapse.**
+- `Unknown` is not `False` and not a low-confidence guess. It raises if used as a boolean.
+- `Verdict` has three states. `fails` and `unknown` are different.
+- `Receipt` separates "did not happen" from "may have happened".
+- `Score` says what kind of number it is. A similarity is not a probability, and a
+  probability must name the data it was calibrated on.
+
+**The runtime binds implementations by policy.** An implementation declares `Traits`
+(locality, egress, determinism, requirements) and a measured `Profile`. `Policy` filters
+on hard constraints and orders a cascade; `Budget` caps cost and attempts across calls.
+Unmeasured means unknown: a missing cost is never counted as zero, and a cost cap excludes
+implementations whose cost is unknown.
+
+**Records carry evidence.** `Store` holds entity and claim records with evidence, validity
+intervals and scope, and detects conflicts between them.
+
+## Optional extras
+
+| Extra | Installs | For |
+| --- | --- | --- |
+| `learned` | scikit-learn, numpy | `tensorcode.backends.linear` |
+| `local-model` | torch, transformers | `tensorcode.backends.hf_local` |
+| `learned-neural` | torch, transformers | `tensorcode.backends.neural` |
+
+## Examples
+
+The examples live in this repository, not in the package. Run them from a checkout:
+
+| Example | Command |
+| --- | --- |
+| Recovery after failed or ambiguous actions | `python -m examples.recovery.demo` |
+| Knowledge store: ingest, conflicts, queries | `python -m examples.knowledge.demo` |
+| Packing context into a token budget | `python -m examples.context_select.demo` |
+| Support router (needs the Banking77 train CSV) | `python -m examples.support_router.demo --train banking77_train.csv` |
+| Decision service with HTTP API and operator UI | `python -m examples.decisions.service` |
+| Live browser agents, no model calls (needs `playwright`, `numpy`, `pillow`) | `python -m examples.browser_agents.live` |
+
+Expected output is checked in beside each demo (`OUTPUT*.txt`).
+
+## What has been measured, honestly
+
+The design notes in [`docs/revival/`](https://github.com/TensaCo/tensacode-py/blob/main/docs/revival/README.md) report measurements,
+including the unflattering ones:
+
+- A local zero-shot Qwen3-8B escalation tier **lowered** Banking77 selective accuracy from
+  94.1% to 91.0%. Tiers should be admitted only by measured quality.
+- Recovery logic based on explicit facts made 0 duplicate money movements in 5,000
+  simulated episodes, compared with 4.8% for naive retry. The simulator and its fault model
+  are the project's own, and with wrong facts about the target system duplicates return (0.9%).
+- The [evidence audit](https://github.com/TensaCo/tensacode-py/blob/main/docs/revival/11-evidence-audit.md) found that 13 of the project's 19
+  headline results ran in environments it wrote **and** were graded by code it wrote. On
+  public open-domain benchmarks, the cascade did worse than plainly prompting the same
+  model on 3 of 4.
+
+Treat the agent results as demonstrations, not benchmarks.
+
+## Repository layout
+
+```text
+src/tensorcode/  the package
+tests/           pytest suite (some tests use examples/ and eval/)
+examples/        runnable programs and agents
+eval/            evaluation scripts and result files (eval/results/*.json)
+research/        experiments, including a civilization simulation
+docs/revival/    design notes and measurements
+```
+
+## Development
+
+```bash
+pip install -e ".[dev,learned]"
+python -m pytest -q
+```
+
+Evaluation scripts read downloaded datasets and trained artifacts from `$TENSORCODE_SCRATCH`
+(default `~/.cache/tensorcode`). Tests that need those artifacts skip when they are absent.
+
+The legacy 2023–2024 package (`tensacode`, with `Engine` and TCIR; never published) is
+preserved at the git tag `legacy-2024-11`. It was never functional and is not compatible
+with this one. The PyPI name `tensacode` is a placeholder that installs `tensorcode`.
+
+## License
+
+[MIT](https://github.com/TensaCo/tensacode-py/blob/main/LICENSE)

tensorcode-0.1.0a1.dist-info/RECORD

@@ -0,0 +1,53 @@
+tensorcode/__init__.py,sha256=l_9uvB4iV6oudtolL6nAcm9aiuUNtc9OawNb4TeX_lo,1757
+tensorcode/actions.py,sha256=aje5U5B2I5NPS4neaMX3Vonup7_P-r1rF3Esp3RQO9w,5270
+tensorcode/answer_type.py,sha256=VJfyElor9FYWB9uEBASaOm8LDfEY_3R8y_GZw3ID_Wc,11506
+tensorcode/awareness.py,sha256=l-MMW9FiNlzyJybovFiIXVWWmPTIkQ5v7ArLGNgATL4,15478
+tensorcode/causal.py,sha256=hpQZo7nwo8jr7l-J_gctX8ihnoyjHLeclQKy6hmdELg,11339
+tensorcode/change.py,sha256=UidBe9xMxR6wHABgt8jyBFpKYBw_ado21LTmLwqb9Ro,25745
+tensorcode/chunking.py,sha256=PyFZSZd2IB3tU3Epa0R7KFRw2wFCvt-IVJcxrClGnN4,8866
+tensorcode/cognition.py,sha256=8O3yAo1Y_hUS40gVfr8M6namOys8mndICKqr4RZZL20,15248
+tensorcode/context.py,sha256=gaoydZjPlNOyMptOSJgkJcDPLlVO-jB3quxB_TSk3Ow,3289
+tensorcode/control.py,sha256=YMoh4zdfvrvmOIWF337s3U01cV3Z_q-LKcv71QLdppY,14440
+tensorcode/cues.py,sha256=SlzmpCRlfq0IXKdEJWhg1bWAQBMZVagB7EEEamTG7Vs,9084
+tensorcode/expectation.py,sha256=C7t-peMTPFVZ53NYhmw_MB3R1p07sxw7X9GKT_8SbeI,12487
+tensorcode/frames.py,sha256=111aKoy-BsGX4PwYb8Gc82oZEAiTDWZ2CvkZOBCHvA8,10520
+tensorcode/memory.py,sha256=zTc2OPpQ4V6YljwIftcry-Zr6oP-0w2HVX6xEmqqHUU,15431
+tensorcode/metacognition.py,sha256=dDtK0slx9iPUvXDig-elFBbs0OT7b9_2N6Apv385Z3k,15401
+tensorcode/ops.py,sha256=PE_5h-d_s9ya390UChruJ63e1Z7QIRPGlbkDRFjGNfk,9357
+tensorcode/outcomes.py,sha256=jHIz-k4-kMNRzIlYgBn-dZjbaXsYcYbwYV1LksW3T4I,3241
+tensorcode/permanence.py,sha256=AJVx5hHWDiJyt7MD4DOz8xCYN4Lpurj-TDyknYh1GDg,16828
+tensorcode/priming.py,sha256=loygI3tpvXqDwNRFQo2ziL3H1pni8AFNcZN6vQnKtp4,8712
+tensorcode/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tensorcode/quantity.py,sha256=vE1uHxdt309-ceQJlabUjRI4xvYDcOluum0aSC68aQ4,12712
+tensorcode/records.py,sha256=22PIx2UlR53Qno8wJJd4DzELgCSD0W60IRtFVnHwVQ0,28792
+tensorcode/relation.py,sha256=l0FTze-ehHTnay24MKccHX81VBdTsKjJC68dAwfbJ3A,38445
+tensorcode/runtime.py,sha256=VIrJ6CD3wSfzQw2_OXI3mjttvJTp8TjLpNPUrersHrY,18717
+tensorcode/semantics_bridge.py,sha256=OB9PxMDQd-6uxuPpgooKaYVHBV3bAqRrjEBQvWEr1EA,14044
+tensorcode/social.py,sha256=123-p5sV9EZfpXlSNvpUuUjvVuNs6oB-d2Y680M1BSI,15571
+tensorcode/temporal.py,sha256=TzdXKR0mjT2y4VqWgEzdJHNLwfw3Ea1EFWapiDrEAbs,8131
+tensorcode/wants.py,sha256=PikmA8J4lpmZvBfPVn1erKMwG3AXpUFyvjj4mhgU-A4,7998
+tensorcode/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tensorcode/backends/builtin.py,sha256=7PYSON5zIBN8ODewf-2kAPYY0hea7UZkx3nYCPFQxE8,6380
+tensorcode/backends/hf_local.py,sha256=QcEbb1aRG2L32Jf5QwZZ25VnZ6_luMlUbICCBlLw-ag,3859
+tensorcode/backends/linear.py,sha256=SzWO7xSXfeNIZfjAXACCJkSkBT-QxzaiHBExA9hTPCY,5192
+tensorcode/backends/neural.py,sha256=kimyRKZ66u5Gy0n89uGnGt1ZjEJ10lpQqvVK85-K6xY,17664
+tensorcode/language/__init__.py,sha256=gt8RZKBT0V3g06OO4sjJ-STOFV0unnal4HAfiZ6JdxY,1913
+tensorcode/language/chart.py,sha256=yW_J4OVY-fjkcM7wMzgXnTiIWX18850XQeiKUDBszpc,24453
+tensorcode/language/discourse.py,sha256=YMFDI_q-2hKW8THOwED3WpQMwfLSkEIai0lCQSlK-o4,5778
+tensorcode/language/english.py,sha256=5_DubSoy2TY_17NCqL7yTk7qgPxuNuAHlQTgkKkCrUE,30323
+tensorcode/language/features.py,sha256=gEkHNiEwQ2PGP66WIRhB4UPjeHsTjLTbdVXz5Dfc10o,3685
+tensorcode/language/generate.py,sha256=YdeZG_q15bZtpOZ2IjXpMRwKcWPez1Oxo94tyakZFC8,25516
+tensorcode/language/grammar.py,sha256=ohDAc9QjV3VW6SDGLP94DBERdth0Urw3Mmfuo3uDc2Y,38625
+tensorcode/language/semantics.py,sha256=zZbcIo-_diigCV-sNB5sxsTGGM7TEUOA36mzkOZG0z0,14014
+tensorcode/language/domains/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tensorcode/language/domains/desktop.py,sha256=EE5OkwamI42N4K4LOc7G8njuQfWqAVDr0JLfedTpsZI,27227
+tensorcode/learning/__init__.py,sha256=fug2qJJCzkndvGkIEP0Cj_sHnNUGwxPi0yEBntm82X8,1931
+tensorcode/learning/certificate.py,sha256=GO3OIWgHNmtQeKa_ubbzDbcKOpL3FKG6htIBncftLI0,5841
+tensorcode/learning/induce.py,sha256=1Je9ww3LEBYB7455UWYz53VIgBPcLPxsBB4ARkUku3k,12674
+tensorcode/learning/library.py,sha256=1_P7K3hNDArEcqUZCv3OkkzmeMFxeLZwCc6ICbhlzv8,8973
+tensorcode/learning/literals.py,sha256=M2ZNkWc9OsHQ46NsqhQ5S5Zf0zG8ordz9UFQuvSaz0c,5153
+tensorcode/learning/verify.py,sha256=8cZ3th6Ykh1MKq-jjRQGAWTp4PqFlZacRC68pRgGgAY,11216
+tensorcode-0.1.0a1.dist-info/METADATA,sha256=Q6-TmA7oOL24IIWiQgMecILsO7uoKsPKtDFoFZhti1M,8391
+tensorcode-0.1.0a1.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+tensorcode-0.1.0a1.dist-info/licenses/LICENSE,sha256=TiTkvbmxCUbINDzXo4oFwhjC6LR417aOQ8y-wh2pNVM,1074
+tensorcode-0.1.0a1.dist-info/RECORD,,

tensorcode-0.1.0a1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.3
+Root-Is-Purelib: true
+Tag: py3-none-any

tensorcode-0.1.0a1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-2026 Jacob Valdez
+
+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.