Upload 5 files

Dockerfile

@@ -0,0 +1,18 @@
+# Utiliser Python 3.11 slim
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Copier le code et la base SQLite
+COPY requirements.txt .
+COPY app ./app
+COPY data ./data/
+
+# Installer les dépendances
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Exposer le port FastAPI
+EXPOSE 8000
+
+# Lancer FastAPI
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

app/database.py

@@ -0,0 +1,47 @@
+import sqlite3
+from typing import List, Dict
+from pathlib import Path
+
+# Chemin vers la base SQLite
+DB_PATH = Path("data/articles.db")
+
+def get_connection():
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+def fetch_tags() -> List[str]:
+    """Retourne tous les tags"""
+    conn = get_connection()
+    cur = conn.cursor()
+    cur.execute("SELECT tag_name FROM tags ORDER BY tag_name")
+    tags = [row["tag_name"] for row in cur.fetchall()]
+    conn.close()
+    return tags
+
+
+def fetch_articles_by_tags(tags: List[str]) -> List[Dict]:
+    """
+    Retourne les articles correspondant aux tags.
+    """
+    if not tags:
+        return []
+
+    conn = get_connection()
+    conn.row_factory = sqlite3.Row
+    cur = conn.cursor()
+
+    # Créer la liste de placeholders "?" dynamiquement
+    placeholders = ",".join(["?"] * len(tags))
+
+    query = ("""SELECT a.article_id, a.article_title, a.article_url
+                  FROM tags t, articles a, tag_article ta
+                 WHERE ta.tag_id = t.tag_id
+                   AND ta.article_id = a.article_id
+                   AND t.tag_name IN (""" + placeholders + """)"""
+    )
+
+    cur.execute(query, tags)
+    results = [dict(row) for row in cur.fetchall()]
+    conn.close()
+    return results

app/main.py

@@ -0,0 +1,39 @@
+from fastapi import FastAPI, Query
+from typing import List
+from app import database
+from fastapi.middleware.cors import CORSMiddleware
+
+app = FastAPI(
+    title="Articles API",
+    description="API pour récupérer articles et tags depuis SQLite",
+    version="1.0"
+)
+
+# CORS pour permettre l'accès depuis le navigateur
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # autorise toutes les origines
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/get_tags")
+def get_tags():
+    """
+    Retourne la liste de tous les tags
+    """
+    tags = database.fetch_tags()
+    return {"tags": tags}
+
+@app.get("/get_articles_with_tags")
+def get_articles_with_tags(
+    tags: List[str] = Query(..., description="Liste des tags à filtrer"),
+    mode: str = Query("AND", description="Mode de filtrage : AND ou OR")
+):
+    """
+    Retourne les articles correspondant aux tags donnés
+    """
+    articles = database.fetch_articles_by_tags(tags, mode)
+    return {"tags": tags,
+            "articles": articles}

requirements.txt

@@ -0,0 +1,4 @@
+fastapi==0.109.2
+uvicorn[standard]==0.23.2
+pandas==2.1.1
+pyarrow==12.0.1

script/create_sqlite_db.py

@@ -0,0 +1,99 @@
+import sqlite3
+import pandas as pd
+import itertools
+import ast
+import uuid
+from pathlib import Path
+
+# Initialisations
+print("Initialisations ...")
+DATA_DIR = Path("../data")   # dossier parent du script
+PARQUET_FILE = DATA_DIR / "medium_articles.parquet"
+SQLITE_FILE = DATA_DIR / "articles.db"
+# Créer le dossier data s'il n'existe pas
+DATA_DIR.mkdir(exist_ok=True)
+
+# Chargement des données
+print("Chargement des données ...")
+df = pd.read_parquet(PARQUET_FILE)
+
+# Initialisations de la base SQLite
+print("Initialisations de la base SQLite ...")
+conn = sqlite3.connect(SQLITE_FILE)
+cur = conn.cursor()
+
+# Suppression des anciennes tables
+cur.execute("DROP TABLE IF EXISTS tag_article")
+cur.execute("DROP TABLE IF EXISTS tags")
+cur.execute("DROP TABLE IF EXISTS articles")
+
+# Création des tables Articles, Tags, et de la table d'association articles <-> tags
+cur.execute("""
+CREATE TABLE articles (
+    article_id TEXT PRIMARY KEY,         -- UUID
+    article_title TEXT,
+    article_text TEXT,
+    article_url TEXT,
+    article_authors TEXT,
+    article_date TEXT                    -- YYYY-MM-DD
+)""")
+
+cur.execute("""
+CREATE TABLE tags (
+    tag_id INTEGER PRIMARY KEY AUTOINCREMENT,
+    tag_name TEXT UNIQUE
+)""")
+
+cur.execute("""
+CREATE TABLE tag_article (
+    tag_article_id INTEGER PRIMARY KEY AUTOINCREMENT,
+    article_id TEXT,
+    tag_id INTEGER,
+    FOREIGN KEY(article_id) REFERENCES articles(article_id),
+    FOREIGN KEY(tag_id) REFERENCES tags(tag_id)
+)""")
+
+# Extraction des tags en une liste unique
+print("Extraction des tags en une liste unique ...")
+df['list_tags'] = df['tags'].apply(lambda x: ast.literal_eval(x) if isinstance(x, str) else [])
+# Extraire tous les tags uniques
+all_tags = list(set(itertools.chain.from_iterable(df['list_tags'])))
+
+# Insertion des tags dans la table
+print("Insertion des tags dans la table ...")
+cur.executemany("INSERT INTO tags (tag_name) VALUES (?)", [(tag,) for tag in all_tags])
+
+# Récupération des correspondances tag_name -> tag_id
+print("Récupération des correspondances tag_name -> tag_id ...")
+cur.execute("SELECT tag_id, tag_name FROM tags")
+dict_tag_map = {tag_name: tag_id for tag_id, tag_name in cur.fetchall()}
+
+# Insertion des articles et table d'association dans les tables
+print("Insertion des articles et table d'association dans les tables ...")
+for _, row in df.iterrows():
+    # Détermination de l'id article
+    article_id = str(uuid.uuid4())
+
+    # Extraction de la date du timestamp
+    date_value = None
+    if pd.notna(row["timestamp"]):
+        try:
+            date_value = str(pd.to_datetime(row["timestamp"]).date())
+        except Exception:
+            date_value = None
+
+    # Insertion dans la table Articles
+    cur.execute("""
+        INSERT INTO articles (article_id, article_title, article_text, article_url, article_authors, article_date)
+        VALUES (?, ?, ?, ?, ?, ?)""",
+               (article_id, row["title"], row["text"], row["url"], row["authors"], date_value))
+
+    # Association aux tags
+    for tag_name in row['list_tags']:
+        tag_id = dict_tag_map[tag_name]
+        cur.execute("INSERT INTO tag_article (article_id, tag_id) VALUES (?, ?)",
+                    (article_id, tag_id))
+
+conn.commit()
+conn.close()
+print("Traitement terminé.")