mkdir regulatory-fine-alert
cd regulatory-fine-alert

# (optional) create a virtual environment
python -m venv .venv
source .venv/bin/activate   # on Windows: .venv\Scripts\activate

# install dependencies
pip install --upgrade pip
pip install requests python-dotenv tqdm   # tqdm for a nice progress bar (optional)

# Initialize a Node.js project (accept defaults)
npm init -y

# Install core libs
npm install axios dotenv

# (Optional) install TypeScript if you prefer TS
npm install --save-dev typescript @types/node ts-node
npx tsc --init   # creates tsconfig.json

# .env  –  keep this secret!
NEWSAPI_KEY=your_newsapi_key_here

#!/usr/bin/env python3
"""
regulatory-fine-alert: Python version
Fetches latest news about the Temu DSA fine from NewsAPI.org.
"""

import os
import sys
import time
import logging
from typing import List, Dict

import requests
from dotenv import load_dotenv
from tqdm import tqdm  # optional progress bar

# ----------------------------------------------------------------------
# Configuration & Logging
# ----------------------------------------------------------------------
load_dotenv()  # loads .env into os.environ
NEWSAPI_KEY = os.getenv("NEWSAPI_KEY")
if not NEWSAPI_KEY:
    sys.exit("❌ ERROR: NEWSAPI_KEY not set in environment or .env file")

NEWS_ENDPOINT = "https://newsapi.org/v2/everything"
QUERY = '"Temu" AND ("Digital Services Act" OR "DSA" OR "€200 million")'
PARAMS = {
    "q": QUERY,
    "language": "en",
    "sortBy": "publishedAt",
    "pageSize": 10,          # number of results per request
    "apiKey": NEWSAPI_KEY,
}

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(message)s",
    datefmt="%H:%M:%S",
)
logger = logging.getLogger(__name__)

# ----------------------------------------------------------------------
# Core logic
# ----------------------------------------------------------------------
def fetch_news(retries: int = 3, backoff_factor: float = 1.0) -> List[Dict]:
    """
    Call NewsAPI with exponential backoff retry.
    Returns a list of article dicts (may be empty).
    """
    for attempt in range(1, retries + 1):
        try:
            logger.info(f"Requesting news (attempt {attempt}/{retries})…")
            resp = requests.get(NEWS_ENDPOINT, params=PARAMS, timeout=10)
            resp.raise_for_status()  # raises HTTPError for 4xx/5xx
            data = resp.json()
            if data.get("status") != "ok":
                logger.error(f"API returned non-ok status: {data}")
                return []
            articles = data.get("articles", [])
            logger.info(f"Fetched {len(articles)} article(s).")
            return articles
        except requests.RequestException as exc:
            logger.warning(f"Request failed: {exc}")
            if attempt < retries:
                sleep_time = backoff_factor * (2 ** (attempt - 1))
                logger.info(f"Retrying in {sleep_time:.1f}s…")
                time.sleep(sleep_time)
            else:
                logger.error("Max retries reached – giving up.")
                return []
        except ValueError as json_err:  # includes JSONDecodeError
            logger.error(f"Failed to parse JSON response: {json_err}")
            return []


def display_articles(articles: List[Dict]) -> None:
    """Pretty‑print a list of articles."""
    if not articles:
        logger.info("No articles to display.")
        return

    for i, art in enumerate(articles, start=1):
        title = art.get("title", "(no title)")
        source = art.get("source", {}).get("name", "unknown")
        published = art.get("publishedAt", "unknown")
        url = art.get("url", "#")
        print(f"\n{i}. {title}")
        print(f"   Source: {source} | Published: {published}")
        print(f"   URL: {url}")


def main() -> None:
    articles = fetch_news()
    display_articles(articles)


if __name__ == "__main__":
    main()

python alert.py

/**
 * regulatory-fine-alert: TypeScript version
 * Fetches latest news about the Temu DSA fine from NewsAPI.org.
 */

import axios from "axios";
import dotenv from "dotenv";
import { log, error } from "console";

// Load .env into process.env
dotenv.config();

const NEWSAPI_KEY: string | undefined = process.env.NEWSAPI_KEY;
if (!NEWSAPI_KEY) {
  error("❌ ERROR: NEWSAPI_KEY not set in environment or .env file");
  process.exit(1);
}

const NEWS_ENDPOINT = "https://newsapi.org/v2/everything";
const QUERY = '"Temu" AND ("Digital Services Act" OR "DSA" OR "€200 million")';
const PARAMS = {
  q: QUERY,
  language: "en",
  sortBy: "publishedAt",
  pageSize: 10,
  apiKey: NEWSAPI_KEY,
};

/**
 * Simple exponential backoff helper.
 */
async function sleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

/**
 * Fetch news with retry logic.
 */
async function fetchNews({
  retries = 3,
  backoffFactor = 1000,
}: {
  retries?: number;
  backoffFactor?: number;
} = {}): Promise<any[]> {
  for (let attempt = 1; attempt <= retries; attempt++) {
    try {
      log(`🔎 Requesting news (attempt ${attempt}/${retries})…`);
      const response = await axios.get(NEWS_ENDPOINT, {
        params: PARAMS,
        timeout: 10_000, // ms
      });

      if (response.data.status !== "ok") {
        error(`❌ API returned non-ok status: ${JSON.stringify(response.data)}`);
        return [];
      }

      const articles: any[] = response.data.articles ?? [];
      log(`✅ Fetched ${articles.length} article(s).`);
      return articles;
    } catch (err: any) {
      if (axios.isAxiosError(err)) {
        const msg = err.response?.data?.message ?? err.message;
        log(`⚠️ Request failed: ${msg}`);
      } else {
        log(`⚠️ Unexpected error: ${err}`);
      }

      if (attempt < retries) {
        const delay = backoffFactor * 2 ** (attempt - 1);
        log(`🕒 Retrying in ${delay / 1000}s…`);
        await sleep(delay);
      } else {
        error("❌ Max retries reached – giving up.");
        return [];
      }
    }
  }
  return []; // unreachable but keeps TS happy
}

/**
 * Pretty‑print articles.
 */
function displayArticles(articles: any[]): void {
  if (articles.length === 0) {
    log("📭 No articles to display.");
    return;
  }

  articles.forEach((art, idx) => {
    const title = art.title ?? "(no title)";
    const source = art.source?.name ?? "unknown";
    const published = art.publishedAt ?? "unknown";
    const url = art.url ?? "#";
    log(`\n${idx + 1}. ${title}`);
    log(`   Source: ${source} | Published: ${published}`);
    log(`   URL: ${url}`);
  });
}

/**
 * Main entry point.
 */
async function main(): Promise<void> {
  const articles = await fetchNews();
  displayArticles(articles);
}

// Run if invoked directly
if (require.main === module) {
  main().catch((err) => {
    error("💥 Unhandled error:", err);
    process.exit(1);
  });
}

# If you kept it as .ts:
npx ts-node alert.ts

# Or compile to JS first:
npx tsc alert.ts
node alert.js

def http_get_with_retry(url, params=None, *, retries=3, backoff=1, timeout=10):
    for attempt in range(1, retries + 1):
        try:
            r = requests.get(url, params=params, timeout=timeout)
            r.raise_for_status()
            return r.json()
        except requests.RequestException as e:
            if attempt == retries:
                raise
            wait = backoff * (2 ** (attempt - 1))
            time.sleep(wait)

import pLimit from "p-limit";

const limit = pLimit(2); // max 2 concurrent calls

async function guardedFetch(url: string, params: Record<string, any>) {
  return limit(() => axios.get(url, { params, timeout: 8000 }));
}

// Usage
const data = await guardedFetch(NEWS_ENDPOINT, PARAMS);

import logging, json, sys

class JsonFormatter(logging.Formatter):
    def format(self, record):
        log_record = {
            "timestamp": self.formatTime(record, self.datefmt),
            "level": record.levelname,
            "message": record.getMessage(),
            "module": record.module,
        }
        return json.dumps(log_record)

handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(JsonFormatter())
logger = logging.getLogger("myapp")
logger.setLevel(logging.INFO)
logger.addHandler(handler)

// Simple token bucket: allow N requests per minute
class RateLimiter {
  private tokens: number;
  private readonly max: number;
  private readonly intervalMs: number;
  private lastRefill: number;

  constructor(maxPerMinute: number) {
    this.max = maxPerMinute;
    this.tokens = maxPerMinute;
    this.intervalMs = 60_000 / maxPerMinute;
    this.lastRefill = Date.now();
  }

  async acquire() {
    now = Date.now();
    this.tokens += Math.floor((now - this.lastRefill) / this.intervalMs);
    this.lastRefill = now;
    if (this.tokens > this.max) this.tokens = this.max;

    if (this.tokens < 1) {
      const wait = this.intervalMs - (now - this.lastRefill);
      await new Promise((r) => setTimeout(r, wait));
      return this.acquire();
    }
    this.tokens--;
  }
}

# ---- Base image ----
FROM python:3.12-slim

# ---- Install system deps (if any) ----
RUN apt-get update && apt-get install -y --no-install-recommends \
        gcc libffi-dev && \
    rm -rf /var/lib/apt/lists/*

# ---- Create app dir ----
WORKDIR /app

# ---- Install Python dependencies ----
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# ---- Copy source ----
COPY alert.py .

# ---- Runtime ----
ENV PYTHONUNBUFFERED=1
EXPOSE 8080   # if you add a health endpoint
CMD ["python", "alert.py"]

FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build   # if you have a build step

FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/dist ./dist   # or .ts files if you run ts-node in prod
ENV NODE_ENV=production
EXPOSE 3000
CMD ["node", "dist/alert.js"]