pluto-enem 0.1.0__tar.gz

pluto_enem-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: pluto-enem
+Version: 0.1.0
+Summary: Biblioteca Python para questões, alternativas e imagens do ENEM
+Requires-Python: >=3.10

pluto_enem-0.1.0/pluto/__init__.py

@@ -0,0 +1,5 @@
+from .library import PlutoLibrary
+from .models import Alternative, ImageAsset, Question
+
+__all__ = ["Alternative", "ImageAsset", "PlutoLibrary", "Question"]
+__version__ = "0.1.0"

pluto_enem-0.1.0/pluto/library.py

@@ -0,0 +1,251 @@
+from __future__ import annotations
+
+import json
+import random
+import sqlite3
+from pathlib import Path
+from typing import Iterator, Sequence
+
+from .models import Alternative, ImageAsset, Question
+
+
+class PlutoLibrary:
+    """Biblioteca local de questões do ENEM para pesquisa e montagem de provas."""
+
+    def __init__(self, database_path: str | Path = "Pluto/database/pluto.db") -> None:
+        self.database_path = Path(database_path).expanduser().resolve()
+        if not self.database_path.exists():
+            raise FileNotFoundError(
+                f"Banco não encontrado: {self.database_path}. Execute python3 pluto_import.py primeiro."
+            )
+        self.library_dir = self.database_path.parent.parent
+        self.project_dir = self.library_dir.parent
+
+    def _connect(self) -> sqlite3.Connection:
+        connection = sqlite3.connect(self.database_path)
+        connection.row_factory = sqlite3.Row
+        connection.execute("PRAGMA foreign_keys = ON")
+        return connection
+
+    def _absolute_path(self, value: str | None) -> Path | None:
+        if not value:
+            return None
+        path = Path(value)
+        if path.is_absolute():
+            return path
+        return self.project_dir / path if path.parts[:1] != (self.project_dir.name,) else self.project_dir.parent / path
+
+    def years(self) -> list[int]:
+        with self._connect() as connection:
+            rows = connection.execute("SELECT DISTINCT ano FROM questoes ORDER BY ano").fetchall()
+        return [int(row["ano"]) for row in rows]
+
+    def disciplines(self, year: int | None = None) -> list[str]:
+        query = "SELECT DISTINCT disciplina FROM questoes WHERE disciplina IS NOT NULL"
+        parameters: list[object] = []
+        if year is not None:
+            query += " AND ano = ?"
+            parameters.append(year)
+        query += " ORDER BY disciplina"
+        with self._connect() as connection:
+            rows = connection.execute(query, parameters).fetchall()
+        return [str(row["disciplina"]) for row in rows]
+
+    def languages(self, year: int | None = None) -> list[str]:
+        query = "SELECT DISTINCT idioma FROM questoes WHERE idioma IS NOT NULL"
+        parameters: list[object] = []
+        if year is not None:
+            query += " AND ano = ?"
+            parameters.append(year)
+        query += " ORDER BY idioma"
+        with self._connect() as connection:
+            return [str(row[0]) for row in connection.execute(query, parameters)]
+
+    def count(
+        self,
+        year: int | None = None,
+        discipline: str | None = None,
+        language: str | None = None,
+        with_images: bool | None = None,
+    ) -> int:
+        query = "SELECT COUNT(DISTINCT q.id) FROM questoes q"
+        parameters: list[object] = []
+        if with_images is True:
+            query += " JOIN questao_imagens qi ON qi.questao_id = q.id"
+        query += " WHERE 1=1"
+        if year is not None:
+            query += " AND q.ano = ?"
+            parameters.append(year)
+        if discipline is not None:
+            query += " AND q.disciplina = ?"
+            parameters.append(discipline)
+        if language is not None:
+            query += " AND q.idioma = ?"
+            parameters.append(language)
+        with self._connect() as connection:
+            return int(connection.execute(query, parameters).fetchone()[0])
+
+    def questions(
+        self,
+        year: int | None = None,
+        discipline: str | None = None,
+        language: str | None = None,
+        with_images: bool | None = None,
+        exclude_years: Sequence[int] | None = None,
+        limit: int | None = None,
+        random_order: bool = False,
+    ) -> Iterator[Question]:
+        query = "SELECT DISTINCT q.* FROM questoes q"
+        parameters: list[object] = []
+        if with_images is True:
+            query += " JOIN questao_imagens qi ON qi.questao_id = q.id"
+        query += " WHERE 1=1"
+        if year is not None:
+            query += " AND q.ano = ?"
+            parameters.append(year)
+        if discipline is not None:
+            query += " AND q.disciplina = ?"
+            parameters.append(discipline)
+        if language is not None:
+            query += " AND q.idioma = ?"
+            parameters.append(language)
+        if exclude_years:
+            placeholders = ",".join("?" for _ in exclude_years)
+            query += f" AND q.ano NOT IN ({placeholders})"
+            parameters.extend(exclude_years)
+        query += " ORDER BY RANDOM()" if random_order else " ORDER BY q.ano, q.numero, q.disciplina, q.idioma"
+        if limit is not None:
+            if limit < 1:
+                return
+            query += " LIMIT ?"
+            parameters.append(limit)
+        with self._connect() as connection:
+            for row in connection.execute(query, parameters):
+                yield self._question(connection, row)
+
+    def sample(
+        self,
+        amount: int,
+        discipline: str | None = None,
+        year: int | None = None,
+        exclude_years: Sequence[int] | None = None,
+        seed: int | None = None,
+    ) -> list[Question]:
+        """Retorna uma amostra reprodutível, útil para montar um simulado."""
+        if amount < 1:
+            return []
+        candidates = list(self.questions(
+            year=year, discipline=discipline, exclude_years=exclude_years
+        ))
+        generator = random.Random(seed)
+        generator.shuffle(candidates)
+        return candidates[:amount]
+
+    def get_question(
+        self,
+        year: int,
+        number: int,
+        discipline: str | None = None,
+        language: str | None = None,
+    ) -> Question | None:
+        query = "SELECT * FROM questoes WHERE ano = ? AND numero = ?"
+        parameters: list[object] = [year, number]
+        if discipline is not None:
+            query += " AND disciplina = ?"
+            parameters.append(discipline)
+        if language is not None:
+            query += " AND idioma = ?"
+            parameters.append(language)
+        query += " ORDER BY idioma LIMIT 1"
+        with self._connect() as connection:
+            row = connection.execute(query, parameters).fetchone()
+            return self._question(connection, row) if row else None
+
+    def search(self, text: str, limit: int | None = None) -> Iterator[Question]:
+        pattern = f"%{text}%"
+        query = """
+            SELECT * FROM questoes
+            WHERE COALESCE(titulo, '') LIKE ?
+               OR COALESCE(contexto, '') LIKE ?
+               OR COALESCE(texto_completo, '') LIKE ?
+            ORDER BY ano, numero
+        """
+        parameters: list[object] = [pattern, pattern, pattern]
+        if limit is not None:
+            query += " LIMIT ?"
+            parameters.append(limit)
+        with self._connect() as connection:
+            for row in connection.execute(query, parameters):
+                yield self._question(connection, row)
+
+    def export_jsonl(self, output_path: str | Path, **filters: object) -> int:
+        """Exporta questões completas para treinamento ou processamento posterior."""
+        destination = Path(output_path)
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        count = 0
+        with destination.open("w", encoding="utf-8") as output:
+            for question in self.questions(**filters):
+                record = {
+                    "id": question.id, "ano": question.year, "numero": question.number,
+                    "disciplina": question.discipline, "idioma": question.language,
+                    "titulo": question.title, "contexto": question.context,
+                    "texto_completo": question.full_text,
+                    "alternativa_correta": question.correct_alternative,
+                    "alternativas": [
+                        {"letra": item.letter, "texto": item.text, "correta": item.correct}
+                        for item in question.alternatives
+                    ],
+                    "imagens": [
+                        {"arquivo": str(item.file), "thumbnail": str(item.thumbnail), "origem": item.origin}
+                        for item in question.images
+                    ],
+                    "fonte": question.source,
+                }
+                output.write(json.dumps(record, ensure_ascii=False) + "\n")
+                count += 1
+        return count
+
+    def _question(self, connection: sqlite3.Connection, row: sqlite3.Row) -> Question:
+        alternatives = connection.execute(
+            "SELECT * FROM alternativas WHERE questao_id = ? ORDER BY letra", (row["id"],)
+        ).fetchall()
+        images = connection.execute(
+            """
+            SELECT imagens.*, questao_imagens.origem
+            FROM imagens JOIN questao_imagens ON questao_imagens.imagem_id = imagens.id
+            WHERE questao_imagens.questao_id = ? ORDER BY imagens.id
+            """,
+            (row["id"],),
+        ).fetchall()
+        keys = row.keys()
+        raw = row["dados_api"] if "dados_api" in keys else None
+        try:
+            api_data = json.loads(raw) if raw else None
+        except json.JSONDecodeError:
+            api_data = None
+        return Question(
+            id=int(row["id"]), year=int(row["ano"]), number=int(row["numero"]),
+            discipline=row["disciplina"], language=row["idioma"], title=row["titulo"],
+            context=row["contexto"], alternatives_intro=row["introducao_alternativas"],
+            correct_alternative=row["alternativa_correta"],
+            alternatives=tuple(
+                Alternative(
+                    letter=str(item["letra"]), text=item["texto"],
+                    file=self._absolute_path(item["arquivo"]), correct=bool(item["correta"])
+                ) for item in alternatives
+            ),
+            images=tuple(
+                ImageAsset(
+                    id=str(item["id"]), year=int(item["ano"]), discipline=str(item["disciplina"]),
+                    question_number=int(item["questao"]), file=self._absolute_path(item["arquivo"]),
+                    thumbnail=self._absolute_path(item["thumbnail"]), sha256=str(item["sha256"]),
+                    width=int(item["largura"]), height=int(item["altura"]), origin=item["origem"]
+                ) for item in images
+            ),
+            full_text=row["texto_completo"] if "texto_completo" in keys else row["contexto"],
+            source=(row["fonte"] if "fonte" in keys and row["fonte"] else "enem.dev"),
+            api_data=api_data,
+        )
+
+
+__all__ = ["PlutoLibrary"]

pluto_enem-0.1.0/pluto/models.py

@@ -0,0 +1,54 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class Alternative:
+    letter: str
+    text: str | None
+    file: Path | None
+    correct: bool
+
+
+@dataclass(frozen=True)
+class ImageAsset:
+    id: str
+    year: int
+    discipline: str
+    question_number: int
+    file: Path
+    thumbnail: Path
+    sha256: str
+    width: int
+    height: int
+    origin: str | None = None
+
+
+@dataclass(frozen=True)
+class Question:
+    id: int
+    year: int
+    number: int
+    discipline: str | None
+    language: str | None
+    title: str | None
+    context: str | None
+    alternatives_intro: str | None
+    correct_alternative: str | None
+    alternatives: tuple[Alternative, ...]
+    images: tuple[ImageAsset, ...]
+    full_text: str | None = None
+    source: str = "enem.dev"
+    api_data: dict[str, Any] | None = None
+
+    @property
+    def correct_answer(self) -> Alternative | None:
+        return next((item for item in self.alternatives if item.correct), None)
+
+    @property
+    def has_images(self) -> bool:
+        return bool(self.images)
+
+
+__all__ = ["Alternative", "ImageAsset", "Question"]

pluto_enem-0.1.0/pluto_enem.egg-info/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: pluto-enem
+Version: 0.1.0
+Summary: Biblioteca Python para questões, alternativas e imagens do ENEM
+Requires-Python: >=3.10

pluto_enem-0.1.0/pluto_enem.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+pyproject.toml
+pluto/__init__.py
+pluto/library.py
+pluto/models.py
+pluto_enem.egg-info/PKG-INFO
+pluto_enem.egg-info/SOURCES.txt
+pluto_enem.egg-info/dependency_links.txt
+pluto_enem.egg-info/top_level.txt

pluto_enem-0.1.0/pluto_enem.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pluto_enem-0.1.0/pluto_enem.egg-info/top_level.txt

@@ -0,0 +1 @@
+pluto

pluto_enem-0.1.0/pyproject.toml

@@ -0,0 +1,12 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pluto-enem"
+version = "0.1.0"
+description = "Biblioteca Python para questões, alternativas e imagens do ENEM"
+requires-python = ">=3.10"
+
+[tool.setuptools.packages.find]
+include = ["pluto*"]

pluto_enem-0.1.0/setup.cfg

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