learnstat 0.2.0__py3-none-any.whl

learnstat/setup.py

@@ -0,0 +1,308 @@
+"""Guided AI setup in the terminal: company -> API key -> model -> live check -> save.
+
+    learnstat setup        (or /ai inside a session)
+
+All input/output goes through :class:`IO` so the wizard is easy to test and works
+in a plain terminal, in the learnstat REPL and in Jupyter.
+"""
+
+from __future__ import annotations
+
+import getpass
+import time
+from dataclasses import dataclass, field
+from typing import Callable
+
+from . import config, providers
+from .llm import AIError, LLMAssistant, fetch_models
+
+
+class Cancelled(Exception):
+    """The user left the wizard (q, Ctrl+C or end of input)."""
+
+
+@dataclass
+class IO:
+    ask: Callable[[str], str] = input
+    secret: Callable[[str], str] = getpass.getpass
+    say: Callable[[str], None] = print
+
+    def line(self, prompt: str) -> str:
+        try:
+            return self.ask(prompt).strip()
+        except (EOFError, KeyboardInterrupt):
+            raise Cancelled from None
+
+    def hidden(self, prompt: str) -> str:
+        try:
+            return self.secret(prompt).strip()
+        except (EOFError, KeyboardInterrupt):
+            raise Cancelled from None
+
+    def yes(self, prompt: str, default: bool = True) -> bool:
+        answer = self.line(f"{prompt} [{'Y/n' if default else 'y/N'}] ").lower()
+        return default if not answer else answer in ("y", "yes")
+
+
+@dataclass
+class Draft:
+    provider: providers.Provider
+    base_url: str
+    api_key: str = ""
+    model: str = ""
+    models: list[str] = field(default_factory=list)
+
+    def config(self) -> config.AIConfig:
+        return config.AIConfig(api_key=self.api_key, base_url=self.base_url, model=self.model, provider=self.provider.id)
+
+
+RULE = "-" * 60
+
+
+# ---------------------------------------------------------------------------
+# steps
+
+
+def choose_provider(io: IO) -> providers.Provider:
+    io.say("\nWhich AI company do you want to use?\n")
+    choices = providers.all_choices()
+    for i, p in enumerate(choices, 1):
+        io.say(f"  {i:>2}) {p.name}")
+    while True:
+        answer = io.line("\nNumber (or q to quit): ").lower()
+        if answer in ("q", "quit", "exit"):
+            raise Cancelled
+        if answer.isdigit() and 1 <= int(answer) <= len(choices):
+            return choices[int(answer) - 1]
+        by_name = [p for p in choices if answer and (answer == p.id or answer in p.name.lower())]
+        if len(by_name) == 1:
+            return by_name[0]
+        io.say(f"Please type a number from 1 to {len(choices)}.")
+
+
+def ask_endpoint(io: IO, provider: providers.Provider) -> str:
+    if provider.id != "custom":
+        if provider.note:
+            io.say(f"\n{provider.note}")
+        return provider.base_url
+    io.say("\nAny OpenAI-compatible server works (it must offer /chat/completions).")
+    while True:
+        url = io.line("Base URL (for example https://api.example.com/v1): ")
+        if url.startswith(("http://", "https://")):
+            return url
+        io.say("The address must start with http:// or https://")
+
+
+def ask_key(io: IO, provider: providers.Provider) -> str:
+    if not provider.needs_key:
+        return ""
+    if provider.key_url:
+        io.say(f"\nCreate a key at {provider.key_url}")
+    io.say("Paste your API key (it is hidden while you type; right-click or Ctrl+V pastes in most terminals).")
+    while True:
+        key = io.hidden("API key: ")
+        if key:
+            return key
+        io.say("The key is empty - paste it and press Enter (or Ctrl+C to quit).")
+
+
+def load_models(io: IO, d: Draft) -> str | None:
+    """Fetch the model list. Returns an error message when the key itself is the problem."""
+    io.say("\nChecking your key and loading the available models ...")
+    try:
+        d.models = fetch_models(d.config())
+        io.say(f"  OK - {len(d.models)} models available.")
+        return None
+    except AIError as e:
+        if e.fatal:
+            return str(e)
+        d.models = list(d.provider.models)
+        io.say(f"  Could not load the model list ({e}).")
+        if d.models:
+            io.say("  Showing the usual models instead - you can also type any model name.")
+        else:
+            io.say("  Type the model name you want to use.")
+        return None
+
+
+def choose_model(io: IO, d: Draft) -> str:
+    shown = [m for m in d.models if providers.is_chat_model(m)] or list(d.models)
+    query = ""
+    while True:
+        view = [m for m in shown if query.lower() in m.lower()] if query else shown
+        if view:
+            io.say(f"\nModels{f' matching {query!r}' if query else ''}:\n")
+            for i, m in enumerate(view[:40], 1):
+                io.say(f"  {i:>2}) {m}")
+            if len(view) > 40:
+                io.say(f"  ... and {len(view) - 40} more - type part of a name to filter.")
+        answer = io.line("\nPick a number, type part of a name to filter, or type a full model name: ")
+        if not answer:
+            continue
+        if answer.isdigit() and 1 <= int(answer) <= len(view):
+            return view[int(answer) - 1]
+        exact = [m for m in d.models if m.lower() == answer.lower()]
+        if exact:
+            return exact[0]
+        matches = [m for m in shown if answer.lower() in m.lower()]
+        if len(matches) == 1:
+            return matches[0]
+        if matches:
+            query = answer
+            continue
+        if io.yes(f"'{answer}' is not in the list. Use it as the model name anyway?", default=False):
+            return answer
+        query = ""
+
+
+def verify(io: IO, d: Draft) -> str | None:
+    """Send one tiny request. Returns None when it works, else the error message."""
+    label = d.provider.name.split(" (")[0] if d.provider.id != "custom" else d.base_url
+    io.say(f"\nTesting {label} / {d.model} ...")
+    assistant = LLMAssistant(d.config())
+    started = time.monotonic()
+    reply = assistant.test()
+    if reply is None:
+        return assistant.last_error or "the test request failed"
+    io.say(f"  OK - the model answered in {time.monotonic() - started:.1f}s.")
+    return None
+
+
+def profile_name(io: IO, d: Draft) -> str:
+    name = d.provider.id
+    if d.provider.id == "custom":
+        name = io.line("Name for this endpoint (default: custom): ") or "custom"
+    return name
+
+
+def _save(io: IO, d: Draft, tested: bool) -> str:
+    name = profile_name(io, d)
+    path = config.save_profile(name, d.provider.id, d.base_url, d.api_key, d.model, activate=True)
+    if tested:
+        io.say("")
+        io.say(f"Ready. Saved '{name}' ({d.model}) and made it the active AI.")
+    else:
+        io.say("")
+        io.say(f"Saved '{name}' ({d.model}) without a successful test.")
+    io.say(f"Settings file: {path}")
+    return name
+
+
+def add_provider(io: IO) -> str:
+    """Run the full flow for one new provider. Returns the saved profile name."""
+    provider = choose_provider(io)
+    while True:  # restarts here when the user picks another company
+        d = Draft(provider=provider, base_url=ask_endpoint(io, provider))
+        d.api_key = ask_key(io, provider)
+        reload_models = True
+        while True:
+            if reload_models:
+                problem = load_models(io, d)
+                reload_models = False
+                if problem:  # the key was rejected
+                    io.say("")
+                    io.say(f"X  {problem}")
+                    action = io.line("[r] re-enter key   [p] pick another company   [q] quit: ").lower()
+                    if action == "q":
+                        raise Cancelled
+                    if action == "p":
+                        break
+                    d.api_key = ask_key(io, provider)
+                    reload_models = True
+                    continue
+            if not d.model:
+                d.model = choose_model(io, d)
+            problem = verify(io, d)
+            if problem is None:
+                return _save(io, d, tested=True)
+            io.say("")
+            io.say(f"X  {problem}")
+            action = io.line(
+                "[m] choose another model   [k] re-enter key   [r] retry   [p] another company   "
+                "[s] save anyway   [q] quit: ").lower()
+            if action == "q":
+                raise Cancelled
+            if action == "p":
+                break
+            if action == "s":
+                return _save(io, d, tested=False)
+            if action == "k":
+                d.api_key = ask_key(io, provider)
+                reload_models = True
+                d.model = ""
+            elif action != "r":  # "m" or anything else: pick a model again
+                d.model = ""
+        provider = choose_provider(io)
+
+
+def use_saved(io: IO, name: str) -> bool:
+    """Activate a saved profile after checking it still works. Returns True on success."""
+    prof = config.profiles()[name]
+    cfg = config.AIConfig(api_key=prof.get("api_key", ""), base_url=prof.get("base_url", config.DEFAULT_BASE_URL),
+                          model=prof.get("model", config.DEFAULT_MODEL), provider=prof.get("provider", "custom"),
+                          profile=name)
+    io.say(f"\nTesting {name} / {cfg.model} ...")
+    assistant = LLMAssistant(cfg)
+    started = time.monotonic()
+    if assistant.test() is None:
+        io.say(f"X  {assistant.last_error}")
+        if not io.yes("Use it anyway?", default=False):
+            return False
+    else:
+        io.say(f"  OK - answered in {time.monotonic() - started:.1f}s.")
+    config.set_active(name)
+    io.say(f"Active profile: {name}")
+    return True
+
+
+def describe_profile(name: str, prof: dict, active: bool) -> str:
+    company = providers.get(prof.get("provider"))
+    label = company.name.split(" (")[0] if company and company.id != "custom" else prof.get("base_url", "custom endpoint")
+    star = "  <- active" if active else ""
+    return f"{name}: {label}, model {prof.get('model', config.DEFAULT_MODEL)}, key {config.mask(prof.get('api_key', ''))}{star}"
+
+
+# ---------------------------------------------------------------------------
+# entry point
+
+
+def run_wizard(io: IO | None = None) -> str | None:
+    """Interactive AI setup. Returns the active profile name, or None if the user left without one."""
+    io = io or IO()
+    try:
+        io.say(f"\n{RULE}\n learnstat - AI assistant setup\n{RULE}")
+        while True:
+            saved = config.profiles()
+            if not saved:
+                return add_provider(io)
+            active = config.active_name()
+            io.say("\nSaved AI accounts:\n")
+            names = list(saved)
+            for i, n in enumerate(names, 1):
+                io.say(f"  {i:>2}) {describe_profile(n, saved[n], n == active)}")
+            io.say("\n   n) add a new company / key      d) delete one      s) skip, use offline rules      q) quit")
+            answer = io.line("\nNumber to switch, or a letter: ").lower()
+            if answer == "n":
+                return add_provider(io)
+            if answer in ("s", "skip"):
+                config.set_skip_setup(True)
+                io.say("OK - learnstat will use offline rules. Run `learnstat setup` any time to add an AI.")
+                return None
+            if answer in ("q", "quit"):
+                raise Cancelled
+            if answer == "d":
+                pick = io.line("Number to delete: ")
+                if pick.isdigit() and 1 <= int(pick) <= len(names):
+                    target = names[int(pick) - 1]
+                    if io.yes(f"Delete '{target}' and its stored key?", default=False):
+                        config.remove_profile(target)
+                        io.say(f"Deleted '{target}'.")
+                continue
+            if answer.isdigit() and 1 <= int(answer) <= len(names):
+                if use_saved(io, names[int(answer) - 1]):
+                    return names[int(answer) - 1]
+                continue
+            io.say("Please type a number, n, d, s or q.")
+    except Cancelled:
+        io.say("\nSetup cancelled - nothing was changed after the last saved step.")
+        return config.active_name()

learnstat/suggestions.py

@@ -0,0 +1,64 @@
+"""Suggestion objects and the per-session suggestion history."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Suggestion:
+    rule: str  # machine name of the rule that fired
+    concept: str  # key into knowledge.CONCEPTS for /describe and /learn
+    title: str
+    problem: str  # what may be inappropriate about the current approach
+    alternative: str  # which function / chart would be more suitable
+    rationale: str  # why, for this dataset and objective
+    code: str | None = None  # how to implement it
+    line: int | None = None
+    severity: str = "info"  # info | warning
+    columns: list[str] = field(default_factory=list)
+    source_code: str = ""  # the user's line that triggered this
+    status: str = "pending"  # pending | accepted | rejected
+    origin: str = "rules"  # rules | ai
+    id: int = 0  # assigned by SuggestionHistory in display order
+
+    def render(self, color: bool = False) -> str:
+        tag = "!" if self.severity == "warning" else "i"
+        where = f" (line {self.line})" if self.line else ""
+        out = [
+            f"[{tag}] Suggestion #{self.id}{where}: {self.title}",
+            f"    Issue:       {self.problem}",
+            f"    Instead:     {self.alternative}",
+            f"    Why:         {self.rationale}",
+        ]
+        if self.code:
+            out.append("    How:")
+            out += [f"        {ln}" for ln in self.code.splitlines()]
+        out.append(f"    -> /describe {self.id} to learn more, /accept {self.id} or /reject {self.id}")
+        return "\n".join(out)
+
+
+class SuggestionHistory:
+    def __init__(self) -> None:
+        self.items: list[Suggestion] = []
+
+    def add(self, s: Suggestion) -> Suggestion:
+        s.id = len(self.items) + 1
+        self.items.append(s)
+        return s
+
+    def extend(self, items: list[Suggestion]) -> None:
+        for s in items:
+            self.add(s)
+
+    def get(self, sid: int | None = None) -> Suggestion | None:
+        if sid is None:
+            return self.items[-1] if self.items else None
+        return next((s for s in self.items if s.id == sid), None)
+
+    def latest_pending(self) -> Suggestion | None:
+        return next((s for s in reversed(self.items) if s.status == "pending"), None)
+
+    def seen(self, rule: str, source_code: str) -> bool:
+        """Avoid repeating the same advice for the same line in a session."""
+        return any(s.rule == rule and s.source_code == source_code for s in self.items)

learnstat-0.2.0.dist-info/METADATA

@@ -0,0 +1,199 @@
+Metadata-Version: 2.4
+Name: learnstat
+Version: 0.2.0
+Summary: An AI-assisted learning companion for statistical analysis with pandas, NumPy, SciPy and Matplotlib.
+License: MIT
+Project-URL: Homepage, https://github.com/umorfaruksupto/leanstat
+Project-URL: Repository, https://github.com/umorfaruksupto/leanstat
+Project-URL: PyPI, https://pypi.org/project/learnstat/
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=2.0
+Requires-Dist: numpy>=1.24
+Provides-Extra: viz
+Requires-Dist: matplotlib>=3.7; extra == "viz"
+Provides-Extra: stats
+Requires-Dist: scipy>=1.10; extra == "stats"
+Provides-Extra: jupyter
+Requires-Dist: ipython>=8.0; extra == "jupyter"
+Provides-Extra: all
+Requires-Dist: matplotlib>=3.7; extra == "all"
+Requires-Dist: scipy>=1.10; extra == "all"
+Requires-Dist: ipython>=8.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: matplotlib>=3.7; extra == "dev"
+Requires-Dist: scipy>=1.10; extra == "dev"
+Requires-Dist: ipython>=8.0; extra == "dev"
+Dynamic: license-file
+
+# learnstat
+
+An AI-assisted learning companion for statistical analysis in Python.
+
+You write ordinary **pandas / NumPy / SciPy / Matplotlib** code. learnstat:
+
+1. **Understands your dataset.** It profiles the data once and keeps a Markdown memory file of it.
+2. **Suggests better approaches as you write.** For example, it flags a pie chart of 12 categories and suggests a sorted bar chart, explaining why.
+3. **Explains itself** through `/describe`, `/alternatives`, `/learn`, `/memory` and `/fix`.
+4. **Recovers from mechanical errors.** It fixes typos in column names, methods and keywords, plus missing imports and unclosed brackets, and shows you every change.
+5. **Leaves analytical decisions to you.** Data-quality and statistical-method problems are explained but never "fixed" automatically.
+
+It's not a new language. Everything you learn uses the real pandas, SciPy and Matplotlib APIs, so the skills carry over to the rest of the ecosystem.
+
+[![PyPI](https://img.shields.io/pypi/v/learnstat)](https://pypi.org/project/learnstat/)
+
+## Install
+
+From PyPI: <https://pypi.org/project/learnstat/>
+
+```bash
+pip install "learnstat[all]"      # from PyPI
+pip install -e ".[all]"        # pandas, numpy, matplotlib, scipy, ipython
+pip install -e .               # core only: profiling, rules, recovery
+```
+
+### Add an AI (optional)
+
+Just run `learnstat`. If no AI is set up yet it offers a guided setup, and you can repeat it any time with `learnstat setup` (or `/ai` inside a session):
+
+1. **Choose the company**: OpenAI, Anthropic, Google Gemini, xAI, Mistral, DeepSeek, Groq, Together, OpenRouter, Ollama, LM Studio, or any other OpenAI-compatible endpoint.
+2. **Paste your API key**. The input is hidden, and local servers such as Ollama need no key.
+3. **Pick a model** from the list your key can actually use. Type part of a name to filter.
+4. **learnstat checks it** with a live test request and shows `OK` or the exact problem (rejected key, unknown model, no connection, quota), with options to fix it.
+5. It saves the account and starts the interactive session.
+
+Several accounts can be saved and switched: run `learnstat setup` and pick a number, or use `/ai use <name>` in a session. The AI features need no extra package.
+
+For scripts and CI there is a non-interactive route:
+
+```bash
+learnstat config set api_key  sk-your-key
+learnstat config set base_url https://openrouter.ai/api/v1    # default: the active company's endpoint
+learnstat config set model    openai/gpt-4o-mini
+learnstat config list          # saved accounts       learnstat config use <name>   # switch
+learnstat config test          # one tiny request     learnstat config show         # key is masked
+```
+
+Accounts are stored in `~/.learnstat/config.json` (`learnstat config path` prints the location), readable only by you where the OS allows it. The environment variables `LEARNSTAT_API_KEY`, `LEARNSTAT_BASE_URL` and `LEARNSTAT_MODEL` override the active account for one run.
+
+With an AI configured, explanations are tailored to your dataset, `/review` checks code for issues the rules miss, and the AI can propose fixes for errors the rules can't handle. Without it, everything else still works offline. Pass `--no-ai` to switch it off for one run.
+
+## Use it
+
+### Jupyter
+
+```python
+%load_ext learnstat
+import learnstat as ls
+df = ls.read_csv("survey.csv")      # a normal DataFrame, now profiled into .learnstat/survey.md
+```
+
+```python
+df["country"].value_counts().plot.pie()
+# [!] Suggestion #1 (line 1): Pie chart with 12 categories
+#     Issue:   `country` has 12 categories; slices this numerous are hard to compare by angle.
+#     Instead: A horizontal bar chart of the counts, sorted by size.
+#     Why:     Bars share a common baseline ...
+#     How:     counts = df['country'].value_counts() ...
+```
+
+```
+/describe        <- the concept, why it fits this data, when another method is better
+/accept          <- puts the suggested code in a NEW cell; your cell is untouched
+/reject only 3 countries matter here   <- recorded in memory, not suggested again
+```
+
+When a cell raises an error, learnstat diagnoses the failing statement. If it's a mechanical mistake, learnstat corrects it, re-runs only that statement and the ones after it, and prints the diff. A cell with a syntax error gets a corrected copy placed in the next cell for you to review.
+
+### Command line
+
+```bash
+cd examples && python make_survey.py
+learnstat profile survey.csv           # writes .learnstat/survey.md and prints it
+learnstat check analysis.py            # suggestions only, nothing is executed
+learnstat watch analysis.py            # re-checks every time you save the file
+learnstat run analysis.py              # runs with suggestions and guarded recovery
+learnstat repl --data survey.csv       # interactive, with /commands
+learnstat config show                  # AI settings (see "Add an AI")
+```
+
+### Plain Python
+
+```python
+import learnstat as ls
+df = ls.read_csv("survey.csv")
+ls.check("df['income'].mean()")         # suggestions without running
+print(ls.command("/describe"))
+
+s = ls.Session(confirm=lambda q: input(q + " [y/N] ") == "y")
+s.ns["df"] = s.read_csv("survey.csv")
+result = s.run("df.groupBy('group')['score'].median()")
+print(result.final_code)                # df.groupby(...)... your source is never modified
+```
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `/describe [id]` | Explains the latest (or given) suggestion, or the latest error: the concept, the purpose of the function, why it fits this data, and when something else is better |
+| `/alternatives [id]` | Other ways to reach the same goal, with trade-offs |
+| `/learn [topic]` | A short lesson with an exercise on your own data |
+| `/fix` | The last error diagnosis; in interactive mode, a retry of the failed statement |
+| `/memory [show\|note\|decide\|refresh]` | View or update the dataset's persistent profile |
+| `/accept [id]`, `/reject [id] [why]` | Accept or reject a suggestion; the decision is saved in memory |
+| `/suggestions`, `/review`, `/ask`, `/status`, `/help` | |
+
+## Dataset memory
+
+`ls.read_csv` profiles the data and writes two files to `.learnstat/`:
+
+- `survey.md`: columns, types, missing values, likely column meanings (marked as guesses), distributions, relationships, data-quality issues, suggested analyses, assumptions, **your analytical decisions** and notes.
+- `survey.json`: the machine-readable cache. It includes a content fingerprint, so the data is only re-profiled when it actually changes. Decisions and notes carry over when that happens.
+
+## How error recovery stays safe
+
+- Code runs **one top-level statement at a time**. When statement *k* fails, only statement *k* is corrected and retried, so earlier side effects are never repeated.
+- Errors are classified as **syntax, name, attribute, argument, column, data-quality, statistical-method, environment** or other runtime errors.
+- Only mechanical mistakes are corrected automatically, and only to a unique, high-similarity match.
+- Before a fix runs, it must compile. It must not introduce file, shell or network operations, must not change which variables are assigned, must not add data-altering calls (`dropna`, `fillna`, `astype` and so on), and must not change the statistical method.
+- AI-proposed fixes always need your confirmation. So does retrying a loop or block, since that could repeat side effects.
+- Retries are bounded (`max_attempts`, 3 by default). If the same error comes back, recovery stops and gives you a concrete next step.
+- Code that deletes or overwrites files, runs shell commands or opens network connections only runs after you confirm.
+- **This is a policy layer, not a sandbox.** Your code runs in your Python process with your permissions, exactly as if you had run it yourself.
+
+## Project layout
+
+```
+learnstat/
+  profile.py      dataset profiling (no AI)
+  memory.py       Markdown + JSON dataset memory
+  advisor.py      AST-based, data-aware suggestion rules
+  knowledge.py    offline explanations behind /describe, /alternatives, /learn
+  recovery.py     error diagnosis, fix proposal, validation, bounded retry
+  safety.py       detection of destructive side effects
+  llm.py          optional AI backend (OpenAI-compatible endpoint)
+  config.py       saved AI accounts: provider, api_key, base_url, model
+  providers.py    presets for the AI companies
+  setup.py        guided terminal setup (company -> key -> model -> check)
+  session.py      ties it together; read_csv/track/check/run
+  commands.py     slash commands
+  ipython_ext.py  %load_ext learnstat
+  cli.py          learnstat profile|check|watch|run|repl
+```
+
+Add a rule by writing a function `(call, resolver, code) -> Suggestion | None` in `advisor.py`, appending it to `RULES`, and adding its concept to `knowledge.py`.
+
+## Roadmap
+
+- A language-server (LSP) frontend for suggestions while typing in VS Code and JupyterLab. The advisor is already editor-agnostic.
+- More rules: multiple-comparison corrections, chi-square expected counts, normality checks before parametric tests, time-series plotting.
+- Learning-progress tracking, so advice fades as the user masters a concept.
+
+## Tests
+
+```bash
+pip install -e ".[dev]"
+pytest
+```

learnstat-0.2.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+learnstat/__init__.py,sha256=C3f7siCc35sZLVFnJsRHI-8AerlASu-V1EGjrFnQKCY,2496
+learnstat/advisor.py,sha256=96fxyfxARVtQFNcEn4n1pp1UkgXJWGwBgJXE4rnAYUo,21211
+learnstat/cli.py,sha256=Nwht__ssdKU8D2LA5luZvkmXmRdcamYZD9OlNmPtirk,13306
+learnstat/commands.py,sha256=UTwRJAXw-95qjwYJKuSNFbwDwAQxCHppFmxjc4WBP58,13099
+learnstat/config.py,sha256=5voQrI5yH4tcMzvtDdWmY0bEiDdNwkoF023hTc_n7pY,7339
+learnstat/ipython_ext.py,sha256=OMSZQAY3lw9YGuppCQJhMUO-OO0G5y4fCHjDsxnoMKc,4172
+learnstat/knowledge.py,sha256=GHuDob0aGhzCTwQSXvYyDwVQofzsXTfEonOfGiRIkww,12422
+learnstat/llm.py,sha256=N_ShNvNAi64bE_VKwA35m8HGBd_8rz_SvreKIHcjv2o,13356
+learnstat/memory.py,sha256=xRJUZ0Bv18WtjwD8PHWXt2NClbjW2D__M2s42u1qflI,7501
+learnstat/profile.py,sha256=LohZ4E_HLsnXr-ncNDza1EC_a2KIDv2S3RPIEvFM2JQ,13377
+learnstat/providers.py,sha256=Z7g2cd_8F2gmoDpCDSSTnGnUCDCTFlDUX6pH3iJSRyY,3440
+learnstat/recovery.py,sha256=70ALYY-sjB0cRg16MGOFPND55sMlxW7DwhEw78r-nBo,48474
+learnstat/safety.py,sha256=yolj4foYo03aPXnM802TMjms-JuO4oQ6feXC-Q4YRnw,4254
+learnstat/session.py,sha256=ulIjOPeCggHjManShhxxqKiZ8IEUFqTyrFaD0sIiWBw,13292
+learnstat/setup.py,sha256=5JvYDhdGBCt4mSPAK1seDO2NzaGFWIEROvWpTbvuJ38,12280
+learnstat/suggestions.py,sha256=UteehmSJHGlbh2j-wvu6rB107kVSzI6EOShmMTROppQ,2507
+learnstat-0.2.0.dist-info/licenses/LICENSE,sha256=H3PxNCq3f9tgoYAk-9yQU36dCVjsYFcj4Sc97kdqvRY,1094
+learnstat-0.2.0.dist-info/METADATA,sha256=mbUkyMintdWCxdAL-gqSZHeYDYbdQfV32HfAylcKOUo,10494
+learnstat-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+learnstat-0.2.0.dist-info/entry_points.txt,sha256=2GGW9VTdCu1dXtpv0OvrLVGm9kQzsRgCvQ9xy1XHfOg,49
+learnstat-0.2.0.dist-info/top_level.txt,sha256=D9hHzVC0PYxXVk2MaIrkuCRd59BKcHJZzVbhhCsJZZ8,10
+learnstat-0.2.0.dist-info/RECORD,,

learnstat-0.2.0.dist-info/WHEEL

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

learnstat-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+learnstat = learnstat.cli:main

learnstat-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Umor Faruk Supto
+
+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.

learnstat-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+learnstat