moodlesolver 1.0.0__tar.gz

moodlesolver-1.0.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: moodlesolver
+Version: 1.0.0
+Summary: Async Moodle quiz automation client with a Telethon-style session API
+License: MIT
+Keywords: moodle,async,automation,quiz
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: AsyncIO
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.9
+
+# MoodleSolver
+
+Async Moodle quiz automation client with a Telethon-style session API.
+
+## Features
+
+- **Telethon-style session**: `start()`, `connect()`, `disconnect()`, `is_connected`
+- **Fully async** on top of `aiohttp` and a Camofox browser API
+- **Multi-client**: run several accounts in parallel, each with its own browser profile; `disconnect()` only touches that client's tabs
+- **All question types**: single choice, multiple choice, text answers, matching, image questions
+- **Question dumps**: every question saved as JSON (+ optional JPG image) for offline analysis
+- **Review parser**: fetch attempt reviews after submission
+- **Result tracking**: read the final grade table
+
+## Requirements
+
+- Python 3.10+
+- A running Camofox browser API (default `http://localhost:9377`)
+
+## Install
+
+```sh
+pip install moodlesolver
+```
+
+## Quick start
+
+```python
+import asyncio
+from moodlesolver import AsyncMoodle
+
+async def main():
+    async with AsyncMoodle(
+        site="https://moodle.example.edu",
+        username="user@example.edu",
+        password="secret",
+    ) as m:
+        print("logged in as", await m.whoami())
+
+        await m.resume_attempt(quiz_id=123)
+        q = await m.current_page()
+        print(q["number"], q["text"], [o["label"] for o in q["options"]])
+
+        r, nxt = await m.answer_step(["correct answer label"])
+        print("answered", r, "timer left", nxt["timer"])
+
+        await m.finish_attempt()
+        print(await m.quiz_result(quiz_id=123))
+
+asyncio.run(main())
+```
+
+## Session lifecycle
+
+```python
+m = AsyncMoodle(site=..., username=..., password=...)
+await m.connect()            # open HTTP session to the browser API
+await m.start()              # login (or reuse an existing session)
+...
+await m.disconnect()         # close this client's tabs and session
+```
+
+`AsyncMoodle` also works as an async context manager (`async with`).
+
+## API overview
+
+| Method | Description |
+|---|---|
+| `start() / connect() / disconnect()` | Session lifecycle |
+| `login(u, p) / whoami()` | Authentication |
+| `new_tab(url) / pick(substr) / tabs() / close_stale()` | Tab management |
+| `current_page()` | Parse the current question (type, options, timer) |
+| `answer_step(labels)` | Answer by label text, then submit ("next") in one step |
+| `answer_text(text)` | Fill a text-answer input |
+| `answer_match(pairs)` | Fill matching selects |
+| `download_image(path) / download_all_images(prefix)` | Export question images |
+| `dump_question(q, quiz_id) / step_quiz(quiz_id, bank)` | Dump questions and drive a full quiz from an answer bank |
+| `resume_attempt(quiz_id) / finish_attempt() / quiz_result(quiz_id) / review(attempt, cmid)` | Quiz lifecycle |
+
+## Question bank format
+
+`step_quiz` accepts a dict mapping question text (case-insensitive substring) to the answer:
+
+```python
+bank = {
+    "Some question text": "single answer label",
+    "Pick all that apply": ["first", "second"],
+}
+```
+
+## License
+
+MIT

moodlesolver-1.0.0/README.md

@@ -0,0 +1,93 @@
+# MoodleSolver
+
+Async Moodle quiz automation client with a Telethon-style session API.
+
+## Features
+
+- **Telethon-style session**: `start()`, `connect()`, `disconnect()`, `is_connected`
+- **Fully async** on top of `aiohttp` and a Camofox browser API
+- **Multi-client**: run several accounts in parallel, each with its own browser profile; `disconnect()` only touches that client's tabs
+- **All question types**: single choice, multiple choice, text answers, matching, image questions
+- **Question dumps**: every question saved as JSON (+ optional JPG image) for offline analysis
+- **Review parser**: fetch attempt reviews after submission
+- **Result tracking**: read the final grade table
+
+## Requirements
+
+- Python 3.10+
+- A running Camofox browser API (default `http://localhost:9377`)
+
+## Install
+
+```sh
+pip install moodlesolver
+```
+
+## Quick start
+
+```python
+import asyncio
+from moodlesolver import AsyncMoodle
+
+async def main():
+    async with AsyncMoodle(
+        site="https://moodle.example.edu",
+        username="user@example.edu",
+        password="secret",
+    ) as m:
+        print("logged in as", await m.whoami())
+
+        await m.resume_attempt(quiz_id=123)
+        q = await m.current_page()
+        print(q["number"], q["text"], [o["label"] for o in q["options"]])
+
+        r, nxt = await m.answer_step(["correct answer label"])
+        print("answered", r, "timer left", nxt["timer"])
+
+        await m.finish_attempt()
+        print(await m.quiz_result(quiz_id=123))
+
+asyncio.run(main())
+```
+
+## Session lifecycle
+
+```python
+m = AsyncMoodle(site=..., username=..., password=...)
+await m.connect()            # open HTTP session to the browser API
+await m.start()              # login (or reuse an existing session)
+...
+await m.disconnect()         # close this client's tabs and session
+```
+
+`AsyncMoodle` also works as an async context manager (`async with`).
+
+## API overview
+
+| Method | Description |
+|---|---|
+| `start() / connect() / disconnect()` | Session lifecycle |
+| `login(u, p) / whoami()` | Authentication |
+| `new_tab(url) / pick(substr) / tabs() / close_stale()` | Tab management |
+| `current_page()` | Parse the current question (type, options, timer) |
+| `answer_step(labels)` | Answer by label text, then submit ("next") in one step |
+| `answer_text(text)` | Fill a text-answer input |
+| `answer_match(pairs)` | Fill matching selects |
+| `download_image(path) / download_all_images(prefix)` | Export question images |
+| `dump_question(q, quiz_id) / step_quiz(quiz_id, bank)` | Dump questions and drive a full quiz from an answer bank |
+| `resume_attempt(quiz_id) / finish_attempt() / quiz_result(quiz_id) / review(attempt, cmid)` | Quiz lifecycle |
+
+## Question bank format
+
+`step_quiz` accepts a dict mapping question text (case-insensitive substring) to the answer:
+
+```python
+bank = {
+    "Some question text": "single answer label",
+    "Pick all that apply": ["first", "second"],
+}
+```
+
+## License
+
+MIT

moodlesolver-1.0.0/moodlesolver/__init__.py

@@ -0,0 +1,6 @@
+"""MoodleSolver: async Moodle quiz client over a Camofox browser API."""
+from .client import AsyncMoodle, AsyncTab, CamofoxError
+from .parse import parse_page
+
+__version__ = "1.0.0"
+__all__ = ["AsyncMoodle", "AsyncTab", "CamofoxError", "parse_page"]

moodlesolver-1.0.0/moodlesolver/client.py

@@ -0,0 +1,406 @@
+import asyncio
+import base64
+import hashlib
+import json
+import os
+import re
+
+import aiohttp
+
+
+class CamofoxError(Exception):
+    pass
+
+
+class AsyncTab:
+    def __init__(self, session, user, tab_id):
+        self.s = session
+        self.user = user
+        self.id = tab_id
+
+    async def _post(self, path, body):
+        async with self.s.post(path, json=body,
+                               timeout=aiohttp.ClientTimeout(total=90)) as r:
+            d = await r.json()
+            if r.status >= 400:
+                raise CamofoxError(f"HTTP {r.status}: {str(d)[:200]}")
+            return d
+
+    async def _get(self, path):
+        async with self.s.get(path,
+                              timeout=aiohttp.ClientTimeout(total=90)) as r:
+            return await r.json()
+
+    async def snapshot_raw(self):
+        return await self._get(f"/tabs/{self.id}/snapshot?userId={self.user}")
+
+    async def snapshot(self, tries=5, delay=3):
+        for _ in range(tries):
+            d = await self.snapshot_raw()
+            s = d.get("snapshot") or ""
+            if s:
+                return s
+            await asyncio.sleep(delay)
+        raise CamofoxError(f"empty snapshot {self.id}")
+
+    async def main_content(self):
+        s = await self.snapshot()
+        a, b = s.find("Содержимое"), s.find("Блоки")
+        if a >= 0 < b:
+            return s[a + 9:b]
+        a, b = s.find("Main content"), s.find("Blocks")
+        if a >= 0 < b:
+            return s[a + 13:b]
+        return s
+
+    async def click(self, ref):
+        return await self._post(f"/tabs/{self.id}/click",
+                                {"userId": self.user, "ref": ref})
+
+    async def type(self, ref, text):
+        return await self._post(f"/tabs/{self.id}/type",
+                                {"userId": self.user, "ref": ref, "text": text})
+
+    async def select(self, ref, option):
+        return await self._post(f"/tabs/{self.id}/select",
+                                {"userId": self.user, "ref": ref, "option": option})
+
+    async def navigate(self, url, settle=2):
+        r = await self._post(f"/tabs/{self.id}/navigate",
+                             {"userId": self.user, "url": url})
+        await asyncio.sleep(settle)
+        return r
+
+    async def evaluate(self, expression):
+        return await self._post(f"/tabs/{self.id}/evaluate",
+                                {"userId": self.user, "expression": expression})
+
+    async def url(self):
+        d = await self.snapshot_raw()
+        return d.get("url", "")
+
+    async def close(self):
+        async with self.s.delete(f"/tabs/{self.id}",
+                                 params={"userId": self.user}) as r:
+            return await r.json()
+
+    async def js_click_label(self, labels):
+        labs = json.dumps(labels if isinstance(labels, list) else [labels],
+                          ensure_ascii=False)
+        r = await self.evaluate(f"""(() => {{
+            const want = {labs};
+            let n = 0;
+            for (const w of want) {{
+                const el = [...document.querySelectorAll('input[type=checkbox],input[type=radio]')]
+                    .find(x => (x.parentElement.textContent || '').trim().toLowerCase()
+                        .includes(w.toLowerCase()));
+                if (el) {{ el.click(); n++; }}
+            }}
+            return String(n);
+        }})()""")
+        return r.get("result")
+
+    async def js_click_next(self):
+        await self.evaluate(
+            "document.querySelector('input[name=next]').click(); 'ok'")
+
+
+class AsyncMoodle:
+    def __init__(self, site, username=None, password=None,
+                 user=None, api_url="http://localhost:9377",
+                 dumps_dir="moodlesolver_dumps"):
+        self.username = username
+        self.password = password
+        self.site = site.rstrip("/")
+        self.api_url = api_url.rstrip("/")
+        self.user = user or ("moodle_" + hashlib.sha1(
+            (username or "anon").encode()).hexdigest()[:8])
+        self.dumps_dir = dumps_dir
+        self.tab = None
+        self.s = None
+        self._connected = False
+
+    async def __aenter__(self):
+        await self.connect()
+        return self
+
+    async def __aexit__(self, *exc):
+        await self.disconnect()
+
+    @property
+    def is_connected(self):
+        return self._connected
+
+    async def connect(self):
+        if not self._connected:
+            self.s = aiohttp.ClientSession(base_url=self.api_url)
+            self._connected = True
+        return self
+
+    async def start(self):
+        if not self._connected:
+            await self.connect()
+        if self.username and self.password:
+            return await self.login(self.username, self.password)
+        return await self.whoami()
+
+    async def disconnect(self):
+        if self.s:
+            for t in await self.tabs():
+                await AsyncTab(self.s, self.user, t["tabId"]).close()
+            await self.s.close()
+        self.s = None
+        self._connected = False
+
+    async def login(self, username, password):
+        t = await self.pick("login/index.php") or \
+            await self.new_tab(f"{self.site}/login/index.php")
+        s = await t.main_content()
+        if "Вы уже вошли" in s or "Вы зашли" in s or "Logged in" in s:
+            return await self.whoami()
+        m_u = re.search(r'(?:textbox|field) "([^"]*(?:Username|Логин|Пользователь)[^"]*)"\s*\[e(\d+)\]', s)
+        m_p = re.search(r'(?:textbox|field) "([^"]*(?:Password|Пароль)[^"]*)"\s*\[e(\d+)\]', s)
+        m_b = re.search(r'button "([^"]*(?:Log in|Вход|Войти)[^"]*)"\s*\[e(\d+)\]', s)
+        if not (m_u and m_p and m_b):
+            raise CamofoxError(f"login form not parsed: {s[:300]}")
+        await t.type(f"e{m_u.group(2)}", username)
+        await t.type(f"e{m_p.group(2)}", password)
+        await t.click(f"e{m_b.group(2)}")
+        await asyncio.sleep(4)
+        return await self.whoami()
+
+    async def whoami(self):
+        t = await self.pick("my/") or await self.new_tab(f"{self.site}/my/")
+        r = await t.evaluate(
+            "JSON.stringify(document.querySelector('.usertext')?.textContent || null)")
+        u = r.get("result")
+        if u and u != "null":
+            return u.strip('"')
+        s = await t.main_content()
+        m = re.search(r'Вы зашли под именем\s*\n?\s*- link "([^"]+)"', s)
+        if m:
+            return m.group(1)
+        m = re.search(r'You are logged in as\s*\n?\s*- link "([^"]+)"', s)
+        return m.group(1) if m else None
+
+    async def tabs(self):
+        async with self.s.get("/tabs", params={"userId": self.user}) as r:
+            return (await r.json()).get("tabs", [])
+
+    async def new_tab(self, url, settle=3):
+        async with self.s.post("/tabs", json={
+                "userId": self.user, "sessionKey": "s", "url": url}) as r:
+            d = await r.json()
+        t = AsyncTab(self.s, self.user, d["tabId"])
+        await asyncio.sleep(settle)
+        self.tab = t
+        return t
+
+    async def pick(self, url_substr, latest=True):
+        ts = [t for t in await self.tabs() if url_substr in t.get("url", "")]
+        if not ts:
+            return None
+        t = AsyncTab(self.s, self.user,
+                     ts[-1]["tabId"] if latest else ts[0]["tabId"])
+        self.tab = t
+        return t
+
+    async def close_stale(self, keep=""):
+        for t in await self.tabs():
+            if keep and keep in t.get("url", ""):
+                continue
+            await AsyncTab(self.s, self.user, t["tabId"]).close()
+
+    async def current_page(self, tab=None):
+        from .parse import parse_page
+        return parse_page(await (tab or self.tab).main_content())
+
+    async def download_image(self, path="/tmp/moodle_img.jpg", tab=None):
+        t = tab or self.tab
+        d = (await t.evaluate("""(async () => {
+            const img = document.querySelector('.qtext img, .content img');
+            if (!img) return 'noimg';
+            await new Promise(r => img.complete ? r() : img.onload = r);
+            const c = document.createElement('canvas');
+            c.width = img.naturalWidth; c.height = img.naturalHeight;
+            c.getContext('2d').drawImage(img, 0, 0);
+            return c.toDataURL('image/jpeg', 0.9);
+        })()""")).get("result")
+        if not isinstance(d, str) or "," not in d:
+            return None
+        open(path, "wb").write(base64.b64decode(d.split(",")[1]))
+        return path
+
+    async def download_all_images(self, prefix="/tmp/moodle_img", tab=None):
+        t = tab or self.tab
+        d = (await t.evaluate("""(async () => {
+            const imgs = [...document.querySelectorAll('.qtext img, .content img')];
+            const out = [];
+            for (const img of imgs) {
+                await new Promise(r => img.complete ? r() : img.onload = r);
+                const c = document.createElement('canvas');
+                c.width = img.naturalWidth; c.height = img.naturalHeight;
+                c.getContext('2d').drawImage(img, 0, 0);
+                out.push(c.toDataURL('image/jpeg', 0.9));
+            }
+            return JSON.stringify(out);
+        })()""")).get("result")
+        try:
+            arr = json.loads(d or "[]")
+        except Exception:
+            return []
+        paths = []
+        for i, data in enumerate(arr):
+            if isinstance(data, str) and "," in data:
+                p = f"{prefix}_{i}.jpg"
+                open(p, "wb").write(base64.b64decode(data.split(",")[1]))
+                paths.append(p)
+        return paths
+
+    async def answer_text(self, text, tab=None):
+        t = tab or self.tab
+        r = await t.evaluate(f"""(() => {{
+            const el = [...document.querySelectorAll('.qtext ~ * input[type=text], input[type=text]')]
+                .filter(x => !x.name.includes('sesskey'))[0];
+            if (!el) return 'notext';
+            el.focus();
+            el.value = {json.dumps(text, ensure_ascii=False)};
+            el.dispatchEvent(new Event('input', {{bubbles: true}}));
+            el.dispatchEvent(new Event('change', {{bubbles: true}}));
+            return el.value;
+        }})()""")
+        return r.get("result")
+
+    async def answer_match(self, pairs, tab=None):
+        t = tab or self.tab
+        r = await t.evaluate(f"""(() => {{
+            const pairs = {json.dumps(pairs, ensure_ascii=False)};
+            let n = 0;
+            for (const p of pairs) {{
+                const row = [...document.querySelectorAll('tr, .answer li')]
+                    .find(x => (x.textContent || '').includes(p[0]));
+                if (!row) continue;
+                const sel = row.querySelector('select');
+                if (!sel) continue;
+                const opt = [...sel.options].find(o => o.textContent.trim() === p[1]);
+                if (opt) {{ sel.value = opt.value;
+                    sel.dispatchEvent(new Event('change', {{bubbles: true}})); n++; }}
+            }}
+            return String(n);
+        }})()""")
+        return r.get("result")
+
+    def dump(self, name, content):
+        os.makedirs(self.dumps_dir, exist_ok=True)
+        p = f"{self.dumps_dir}/{name}"
+        open(p, "w").write(content if isinstance(content, str)
+                           else json.dumps(content, ensure_ascii=False, indent=1))
+        return p
+
+    async def dump_question(self, q, quiz_id):
+        rec = {"n": q["number"], "text": q["text"],
+               "options": [o["label"] for o in q["options"]],
+               "multi": q["multi"], "timer": q["timer"]}
+        p = await self.download_image(
+            f"{self.dumps_dir}/q{quiz_id}_n{q['number']}.jpg")
+        if p:
+            rec["image"] = p
+        self.dump(f"q{quiz_id}_n{q['number']}.json", rec)
+        return rec
+
+    async def answer_step(self, labels, tab=None):
+        t = tab or self.tab
+        r = await t.js_click_label(labels)
+        await asyncio.sleep(0.7)
+        await t.js_click_next()
+        await asyncio.sleep(2.4)
+        return r, await self.current_page()
+
+    async def step_quiz(self, quiz_id, bank, noans=None, on_question=None):
+        noans = noans if noans is not None else []
+        prev = None
+        while True:
+            q = await self.current_page()
+            if q.get("number") == prev:
+                await asyncio.sleep(2)
+                continue
+            prev = q.get("number")
+            if not q["text"] and not q["options"] and not q.get("selects"):
+                return noans
+            rec = await self.dump_question(q, quiz_id)
+            ans = None
+            for k, v in bank.items():
+                if k.lower() in (q["text"] or "").lower():
+                    ans = v
+                    break
+            if on_question:
+                ans = await on_question(q, ans, rec)
+            if ans:
+                labs = ans if isinstance(ans, list) else [ans]
+                r, nxt = await self.answer_step(labs)
+                if not nxt["next_ref"] and nxt["text"] is None:
+                    return noans
+            else:
+                noans.append(rec)
+                if not q["next_ref"]:
+                    return noans
+                await self.tab.js_click_next()
+                await asyncio.sleep(2.4)
+
+    async def resume_attempt(self, quiz_id):
+        t = await self.pick(f"view.php?id={quiz_id}") or \
+            await self.new_tab(f"{self.site}/mod/quiz/view.php?id={quiz_id}")
+        self.tab = t
+        s = await t.main_content()
+        m = re.search(r'button "(Продолжить текущую попытку|Continue attempt)"[^\[]*\[e(\d+)\]', s)
+        if m:
+            await t.click(f"e{m.group(1)}")
+            await asyncio.sleep(3)
+        at = await self.pick("attempt.php")
+        if at:
+            self.tab = at
+            return at.id
+        return None
+
+    async def finish_attempt(self):
+        q = await self.current_page()
+        if q.get("next_label") and ("Закончить" in q["next_label"]
+                                    or "Finish" in q["next_label"]):
+            await self.tab.js_click_next()
+            await asyncio.sleep(3)
+        t = await self.pick("summary.php")
+        if t:
+            self.tab = t
+        s = await self.tab.main_content()
+        m = re.search(r'button "Отправить всё и завершить[^"]*"[^\[]*\[e(\d+)\]', s)
+        if m:
+            await self.tab.click(f"e{m.group(1)}")
+            await asyncio.sleep(3)
+            s = await self.tab.main_content()
+            m = re.search(r'button "Отправить всё и завершить тест"[^\[]*\[e(\d+)\]', s)
+            if m:
+                await self.tab.click(f"e{m.group(1)}")
+                await asyncio.sleep(6)
+
+    async def quiz_result(self, quiz_id):
+        v = await self.pick(f"view.php?id={quiz_id}") or \
+            await self.new_tab(f"{self.site}/mod/quiz/view.php?id={quiz_id}")
+        await asyncio.sleep(2)
+        s = await v.main_content()
+        self.dump(f"result_{quiz_id}.txt", s)
+        sc = re.search(r'итоговая оценка за этот тест:\s*([\d,]+)/([\d,]+)', s)
+        if sc:
+            return sc.group(1) + "/" + sc.group(2)
+        return re.findall(r'- row "([^"]+Отправлено[^"]*)"', s)
+
+    async def review(self, attempt_id, cmid, showall=True):
+        u = f"{self.site}/mod/quiz/review.php?attempt={attempt_id}&cmid={cmid}"
+        if showall:
+            u += "&showall=1"
+        t = self.tab or await self.new_tab(u)
+        await t.navigate(u)
+        await asyncio.sleep(3)
+        s = await t.snapshot(tries=2)
+        self.dump(f"review_{attempt_id}.txt", s)
+        a = s.find("Содержимое")
+        return s[a:s.find("Блоки")] if a >= 0 else s

moodlesolver-1.0.0/moodlesolver/parse.py

@@ -0,0 +1,42 @@
+import re
+
+ANSWER_TYPES = ("radio", "checkbox", "combobox", "textbox")
+
+
+def parse_page(snapshot):
+    q = {"type": "unknown"}
+    m = re.search(r'heading "Вопрос (\d+)"', snapshot)
+    if not m:
+        m = re.search(r'heading "Question (\d+)"', snapshot)
+    q["number"] = int(m.group(1)) if m else None
+    m = re.search(r'Балл:\s*([\d,]+)', snapshot)
+    if not m:
+        m = re.search(r'Mark[s]?\s*([\d,]+)', snapshot)
+    q["points"] = m.group(1) if m else None
+    m = re.search(r'heading "Текст вопроса".*?\n.*?paragraph: (.+)', snapshot)
+    if not m:
+        m = re.search(r'heading "Question text".*?\n.*?paragraph: (.+)', snapshot)
+    q["text"] = m.group(1).strip() if m else None
+    opts = []
+    for m in re.finditer(r'(radio|checkbox) "([^"]+)" \[e(\d+)\]([^\n]*)', snapshot):
+        opts.append({"ref": "e" + m.group(3), "label": m.group(2),
+                     "type": m.group(1), "checked": "checked" in m.group(4)})
+    q["options"] = opts
+    q["selects"] = [{"ref": "e" + r, "current": l}
+                    for l, r in re.findall(r'combobox[^"\n]*"([^"]+)" \[e(\d+)\]', snapshot)]
+    q["textboxes"] = [{"ref": "e" + r, "label": l}
+                      for l, r in re.findall(r'textbox "([^"]+)" \[e(\d+)\]', snapshot)]
+    m = re.search(r'button "(Следующая страница|Завершить попытку[^"]*|'
+                  r'Next page|Finish attempt[^"]*)"[^\[]*\[e(\d+)\]', snapshot)
+    q["next_ref"] = "e" + m.group(2) if m else None
+    q["next_label"] = m.group(1) if m else None
+    m = re.search(r'Оставшееся время (\d+):(\d+):(\d+)', snapshot)
+    if not m:
+        m = re.search(r'Time remaining (\d+):(\d+):(\d+)', snapshot)
+    q["timer"] = (int(m.group(1)) * 3600 + int(m.group(2)) * 60
+                  + int(m.group(3))) if m else None
+    q["raw"] = snapshot
+    q["multi"] = any(o["type"] == "checkbox" for o in opts)
+    q["has_image"] = bool(q["text"] and ("picture" in q["text"].lower()
+                                         or "картинк" in q["text"].lower()))
+    return q

moodlesolver-1.0.0/moodlesolver.egg-info/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: moodlesolver
+Version: 1.0.0
+Summary: Async Moodle quiz automation client with a Telethon-style session API
+License: MIT
+Keywords: moodle,async,automation,quiz
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: AsyncIO
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.9
+
+# MoodleSolver
+
+Async Moodle quiz automation client with a Telethon-style session API.
+
+## Features
+
+- **Telethon-style session**: `start()`, `connect()`, `disconnect()`, `is_connected`
+- **Fully async** on top of `aiohttp` and a Camofox browser API
+- **Multi-client**: run several accounts in parallel, each with its own browser profile; `disconnect()` only touches that client's tabs
+- **All question types**: single choice, multiple choice, text answers, matching, image questions
+- **Question dumps**: every question saved as JSON (+ optional JPG image) for offline analysis
+- **Review parser**: fetch attempt reviews after submission
+- **Result tracking**: read the final grade table
+
+## Requirements
+
+- Python 3.10+
+- A running Camofox browser API (default `http://localhost:9377`)
+
+## Install
+
+```sh
+pip install moodlesolver
+```
+
+## Quick start
+
+```python
+import asyncio
+from moodlesolver import AsyncMoodle
+
+async def main():
+    async with AsyncMoodle(
+        site="https://moodle.example.edu",
+        username="user@example.edu",
+        password="secret",
+    ) as m:
+        print("logged in as", await m.whoami())
+
+        await m.resume_attempt(quiz_id=123)
+        q = await m.current_page()
+        print(q["number"], q["text"], [o["label"] for o in q["options"]])
+
+        r, nxt = await m.answer_step(["correct answer label"])
+        print("answered", r, "timer left", nxt["timer"])
+
+        await m.finish_attempt()
+        print(await m.quiz_result(quiz_id=123))
+
+asyncio.run(main())
+```
+
+## Session lifecycle
+
+```python
+m = AsyncMoodle(site=..., username=..., password=...)
+await m.connect()            # open HTTP session to the browser API
+await m.start()              # login (or reuse an existing session)
+...
+await m.disconnect()         # close this client's tabs and session
+```
+
+`AsyncMoodle` also works as an async context manager (`async with`).
+
+## API overview
+
+| Method | Description |
+|---|---|
+| `start() / connect() / disconnect()` | Session lifecycle |
+| `login(u, p) / whoami()` | Authentication |
+| `new_tab(url) / pick(substr) / tabs() / close_stale()` | Tab management |
+| `current_page()` | Parse the current question (type, options, timer) |
+| `answer_step(labels)` | Answer by label text, then submit ("next") in one step |
+| `answer_text(text)` | Fill a text-answer input |
+| `answer_match(pairs)` | Fill matching selects |
+| `download_image(path) / download_all_images(prefix)` | Export question images |
+| `dump_question(q, quiz_id) / step_quiz(quiz_id, bank)` | Dump questions and drive a full quiz from an answer bank |
+| `resume_attempt(quiz_id) / finish_attempt() / quiz_result(quiz_id) / review(attempt, cmid)` | Quiz lifecycle |
+
+## Question bank format
+
+`step_quiz` accepts a dict mapping question text (case-insensitive substring) to the answer:
+
+```python
+bank = {
+    "Some question text": "single answer label",
+    "Pick all that apply": ["first", "second"],
+}
+```
+
+## License
+
+MIT

moodlesolver-1.0.0/moodlesolver.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+moodlesolver/__init__.py
+moodlesolver/client.py
+moodlesolver/parse.py
+moodlesolver.egg-info/PKG-INFO
+moodlesolver.egg-info/SOURCES.txt
+moodlesolver.egg-info/dependency_links.txt
+moodlesolver.egg-info/requires.txt
+moodlesolver.egg-info/top_level.txt

moodlesolver-1.0.0/moodlesolver.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

moodlesolver-1.0.0/moodlesolver.egg-info/requires.txt

@@ -0,0 +1 @@
+aiohttp>=3.9

moodlesolver-1.0.0/moodlesolver.egg-info/top_level.txt

@@ -0,0 +1 @@
+moodlesolver

moodlesolver-1.0.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "moodlesolver"
+version = "1.0.0"
+description = "Async Moodle quiz automation client with a Telethon-style session API"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+keywords = ["moodle", "async", "automation", "quiz"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Framework :: AsyncIO",
+    "License :: OSI Approved :: MIT License",
+]
+dependencies = ["aiohttp>=3.9"]
+
+[tool.setuptools.packages.find]
+include = ["moodlesolver*"]

moodlesolver-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+