bibforgery 0.1.0__py3-none-any.whl

bibforgery/cli.py

@@ -0,0 +1,100 @@
+from dotenv import load_dotenv
+from pathlib import Path
+from .tools import (
+    fetch_papers,
+    dump_json_to_file,
+    json_to_bibtex,
+    get_data_from_file,
+)
+from .generators import (
+    generate_json,
+    generate_pdf,
+    generate_txt,
+)
+import argparse, os
+
+
+def main():
+    load_dotenv()
+
+    elsevier_api_key = os.getenv("ELSEVIER_API_KEY")
+    elsevier_inst_token = os.getenv("ELSEVIER_INSTTOKEN")
+
+    parser = argparse.ArgumentParser(
+        description=main.__doc__,
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    parser.add_argument("--fetch", metavar="AUTHOR ID", default="", help="Fetch Scopus API with AUTHOR_ID")
+    parser.add_argument(
+        "--max-entries",
+        metavar="",
+        type=int,
+        default=500,
+        help="Límite máximo de artículos recuperados (útil para testing)",
+    )
+    parser.add_argument("-i", "--input", metavar="BibTex", default="input.txt", help="Nombre de archivo de entrada")
+    parser.add_argument("-o", "--output", metavar="JSON, TXT", default="", help="Nombre de aArchivo de salida")
+    parser.add_argument("--parse", action="store_true", help="Parse JSON to Bibtex")
+    parser.add_argument(
+        "-f",
+        "--format",
+        metavar="{text,json,pdf}",
+        choices=["text", "json", "pdf"],
+        default="",
+        help="Formato de salida",
+    )
+
+    args = parser.parse_args()
+
+    if args.fetch:
+        data = fetch_papers(args.fetch, elsevier_api_key, elsevier_inst_token, args.max_entries)
+
+        output_path_base = Path(f"output/{args.output}" if args.output else "output/result.txt")
+        output_path = output_path_base.with_name(output_path_base.stem + "_raw.json")
+        dump_json_to_file(data, output_path)
+
+        bib_output_file = output_path_base.with_name(output_path_base.stem + ".bib")
+        json_to_bibtex(data, bib_output_file)
+        return
+
+    if not args.parse or not args.format:
+        parser.error("Debes especificar el tipo de uso: --fetch ó --parse")
+
+    if args.format == "json":
+        output_path = Path(f"output/{args.output}" if args.output else "output/parse_result")
+        o_f_ext = output_path.with_name(output_path.stem + ".json")
+        data = get_data_from_file(args.input)
+        json_as_bytes = generate_json(data)
+
+        output_path = Path(o_f_ext).resolve()
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(output_path, "wb") as f:
+            f.write(json_as_bytes.getvalue())
+
+        print("[Info] — JSON created")
+
+    elif args.format == "text":
+        output_path = Path(f"output/{args.output}" if args.output else "output/parse_result")
+        o_f_ext = output_path.with_name(output_path.stem + ".txt")
+        data = get_data_from_file(args.input)
+        text_as_bytes = generate_txt(data)
+
+        output_path = Path(o_f_ext).resolve()
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(output_path, "wb") as file:
+            file.write(text_as_bytes.getvalue())
+
+        print("[Info] — Data created")
+
+    elif args.format == "pdf":
+        output_path = Path(f"output/{args.output}" if args.output else "output/parse_result")
+        o_f_ext = output_path.with_name(output_path.stem + ".pdf")
+        data = get_data_from_file(args.input)
+        pdf_as_bytes = generate_pdf(data)
+
+        output_path = Path(o_f_ext).resolve()
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(output_path, "wb") as f:
+            f.write(pdf_as_bytes)
+
+        print("[Info] — PDF created")

bibforgery/generators.py

@@ -0,0 +1,89 @@
+from .parser import parse_bibtex, process_entries_as_json, process_entries_as_text, get_grouped_entries
+from jinja2 import Template
+from datetime import datetime
+import os, io, json
+
+
+def generate_txt(input: str) -> bytes:
+    """
+    Genera citas en texto plano a partir
+    de un archivo en formato Bibtex y lo
+    guarda en un archivo
+
+    Args:
+        input (string): Archivo de entrada.
+        output (string): Archivo de salida.
+    """
+    
+    bibtext = parse_bibtex(input)
+ 
+    buffer = io.BytesIO()
+    for chunk in process_entries_as_text(bibtext.entries):
+        buffer.write(chunk.encode("utf-8"))
+    buffer.seek(0)
+    return buffer
+
+
+def generate_json(input) -> bytes:
+    """
+    Genera citas en formato JSON a partir
+    de un archivo en formato Bibtex y lo
+    guarda en un archivo
+
+    Args:
+        input (string): Archivo de entrada.
+        output (string): Archivo de salida.
+    """
+   
+    bibtext = parse_bibtex(input)
+
+    buffer = io.BytesIO()
+    buffer.write(b"[")
+    yielder = process_entries_as_json(bibtext.entries)
+    try:
+        first = next(yielder)
+        buffer.write(json.dumps(first, separators=(",", ":"), ensure_ascii=False).encode('utf-8'))
+        for item in yielder:
+            buffer.write(b",")
+            buffer.write(json.dumps(item, separators=(",", ":"), ensure_ascii=False).encode('utf-8'))
+    except StopIteration:
+        pass
+    buffer.write(b"]")
+    buffer.seek(0)
+    return buffer
+
+
+def generate_pdf(input) -> bytes | None:
+    """
+    Generador de archivo PDF a partir
+    de un archivo en formato Bibtex.
+
+    Args:
+        input (string): Archivo de entrada.
+        output (string): Archivo de salida.
+    """
+    
+    from weasyprint import HTML, CSS
+
+    bibtext = parse_bibtex(input)
+
+    base_path = os.path.dirname(os.path.abspath(__file__))
+    templates_path = os.path.join(base_path, "templates/")
+    html_path = os.path.join(base_path, "templates", "index.html")
+    css_path = os.path.join(base_path, "templates", "styles.css")
+
+    with open(html_path, "r", encoding="utf-8") as html:
+        plantilla_html = html.read()
+
+    context = {
+        "grouped_data": get_grouped_entries(bibtext.entries),
+        "date": datetime.now().strftime("%B %d, %Y"),
+    }
+    render = Template(plantilla_html).render(data=context)
+    styles = CSS(filename=css_path)
+    pdf_as_bytes = HTML(
+        string=render,
+        base_url=templates_path,
+    ).write_pdf(stylesheets=[styles])
+
+    return pdf_as_bytes

bibforgery/parser.py

@@ -0,0 +1,184 @@
+from bibtexparser.library import Library
+from bibtexparser.model import Field, Entry
+from collections.abc import MutableSequence
+from collections import defaultdict
+import bibtexparser
+
+
+def parse_bibtex(input) -> Library:
+    bibtext = bibtexparser.parse_string(input)
+    if bibtext.failed_blocks:
+        print(f"[Warning] — Found {len(bibtext.failed_blocks)} Failed Blocks")
+        for block in bibtext.failed_blocks:
+            print(f"\tLine: {block.start_line}")
+            print(f"\tError: {block.error}")
+    return bibtext
+
+
+def transform_authors(author_field: Field):
+    """
+    Convertir datos de autores en formato
+    Bibtex a un string "Apellido, N; Apellido, N"
+
+    Args:
+        author_field (Field): entrada de autores generada por bibtexparser
+    """
+
+    authors = author_field.value.split(" and ")
+    author_list = []
+    for a in authors:
+        parts = a.split(",")
+        family = parts[0]
+        names = parts[1].strip().split(" ")
+        initials = ""
+        for n in names:
+            initials += f"{n[0]}."
+        author_list.append(f"{family}, {initials}")
+    result = "; ".join(author_list)
+    return result
+
+
+def get_grouped_entries(bib_entries: MutableSequence[Entry]):
+    """
+    Args:
+        bib_entries (MutableSequence[Entry]): secuencia de entradas generada por bibtexparser
+
+    Clasifica por año una secuencia de entradas
+    generadas por bibtexparser. Si una entrada no
+    tiene año la clasifica como "Sin Año".
+    """
+
+    def extract_year(entry):
+        y = entry.get("year")
+        try:
+            return int(y.value) if y else 0
+        except (ValueError, AttributeError):
+            return 0
+
+    sorted_entries = sorted(bib_entries, key=extract_year, reverse=True)
+    total_papers = len(sorted_entries)
+
+    grouped = defaultdict(list)
+    for i, entry in enumerate(sorted_entries):
+        global_index = total_papers - i
+
+        year_field = entry.get("year")
+        year = year_field.value if year_field else "Sin Año"
+
+        citation_html = process_single_entry_as_html(entry, global_index)
+        grouped[year].append(citation_html)
+
+    sorted_years = sorted(grouped.keys(), reverse=True)
+    return [(y, grouped[y]) for y in sorted_years]
+
+
+def process_single_entry_as_html(entry: Entry, index: int):
+    """
+    Args:
+        entry (Entry): Entrada generada por bibtexparser
+
+    Returns:
+        String de HTML de una cita bibliográfica
+        a partir de una entrada en formato bibtex
+    """
+
+    author_string = entry.get("author")
+    author_string = transform_authors(author_string)
+
+    title, journal, year, v, n, p, d = (
+        entry.get("title"),
+        entry.get("journal"),
+        entry.get("year"),
+        entry.get("volume"),
+        entry.get("number"),
+        entry.get("pages"),
+        entry.get("doi"),
+    )
+
+    res = f'{author_string} <span style="font-style: italic;">{title.value}</span>. {journal.value}'
+    if year:
+        res += f' <span style="font-weight: bold;">{year.value}</span>'
+    if v or n or p:
+        res += ","
+        if v:
+            res += f" {v.value}"
+        if n:
+            res += f"({n.value})"
+        if p:
+            res += f", {p.value}"
+    if d:
+        res += f'. DOI: <a href="https://doi.org/{d.value}" target="_blank" rel="noopener noreferrer" style="color: #0563C1; text-decoration: underline;">https://doi.org/{d.value}</a>'
+
+    return f"""
+    <div style="display: flex; margin-bottom: 8px;">
+        <div style="min-width: 35px; font-weight: bold;">{index}.</div>
+        <div style="flex: 1;">{res}</div>
+    </div>
+    """
+
+
+def process_entries_as_text(bib_entries: MutableSequence[Entry]):
+    """
+    Args:
+        bib_entries (MutableSequence[Entry]): secuencia de entradas generada por bibtexparser
+
+    Returns:
+        Generador que devuelve una a una (yield) citas
+        en texto plano a partir de una secuencia de
+        entradas en formato bibtex
+    """
+
+    entries = 0
+    for entry in bib_entries:
+        entries += 1
+        author_string = entry.get("author")
+        author_string = transform_authors(author_string)
+
+        title, journal, year, v, n, p, d = (
+            entry.get("title"),
+            entry.get("journal"),
+            entry.get("year"),
+            entry.get("volume"),
+            entry.get("number"),
+            entry.get("pages"),
+            entry.get("doi"),
+        )
+
+        res = f"{author_string} {title.value}. {journal.value} {year.value}"
+        if v:
+            res += f", {v.value}"
+        if n:
+            res += f"({n.value})"
+        if p:
+            res += f", {p.value}"
+        if d:
+            res += f". DOI: {d.value}"
+
+        yield res + "\n" * 2
+    print(f"Total entradas: {entries}")
+
+
+def process_entries_as_json(bib_entries: MutableSequence[Entry]):
+    """
+    Args:
+        bib_entries (MutableSequence[Entry]): secuencia de entradas generada por bibtexparser
+
+    Returns:
+        Generador que devuelve una a una (yield) citas
+        en formato objeto JSON a partir de una secuencia
+        de entradas en formato bibtex
+    """
+
+    for entry in bib_entries:
+        data = {
+            "id": entry.key,
+            "authors": transform_authors(entry.get("author")),
+            "title": entry.get("title").value if entry.get("title") else "",
+            "year": int(entry.get("year").value) if entry.get("year") else None,
+            "journal": entry.get("journal").value if entry.get("journal") else "",
+            "doi": entry.get("doi").value if entry.get("doi") else None,
+            "volume": entry.get("volume").value if entry.get("volume") else "",
+            "number": entry.get("number").value if entry.get("number") else "",
+            "pages": entry.get("pages").value if entry.get("pages") else "",
+        }
+        yield data

bibforgery/templates/index.html

@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <link rel="stylesheet" href="styles.css">
+    <title></title>
+</head>
+
+<body>
+    <!-- <header id="cabecera">
+        <div class="header-container">
+            <img src="img/WatocPNGLogo.png" class="header-logo">
+
+            <div style="display: flex; flex-flow: column; text-align: right; font-weight: bold;">
+                <span>Mérida, Mexico</span>
+                <span>WATOC 2028</span>
+            </div>
+        </div>
+        <hr>
+    </header> -->
+
+    <footer id="foot">
+        <div class="footer-container">
+            <hr>
+            <div class="flex-between">
+                <div>
+                    TheoChemMerida
+                </div>
+                <div>
+                    Last update: {{data['date']}}
+                </div>
+            </div>
+        </div>
+        <div style="text-align: center;">
+            <span class="page-number"></span>
+        </div>
+    </footer>
+
+    <h1 class="title">Publications</h1>
+    <main>
+        {% for year, publications in data['grouped_data'] %}
+        {% for pub_html in publications %}
+            {{ pub_html | safe }}
+        {% endfor %}
+        {% endfor %}
+
+    </main>
+</body>
+
+</html>

bibforgery/templates/styles.css

@@ -0,0 +1,150 @@
+@page {
+    size: letter portrait;
+    padding: 0;
+    margin: 1in 1in 1in 1in;
+
+    @top-center {
+        content: element(cabecera);
+        font-size: 10pt;
+        width: 100%;
+        height: 1in;
+    }
+
+    @bottom-center {
+        content: element(pie);
+        font-size: 10pt;
+        width: 100%;
+        height: 1in;
+    }
+}
+
+.page-break {
+    page-break-after: always;
+}
+
+.page-number {
+    content: counter(page);
+}
+
+.page-number::after {
+    content: counter(page);
+}
+
+
+header#cabecera {
+    position: running(cabecera);
+
+    padding-top: 0cm;
+    padding-bottom: 0;
+
+    width: 100vw;
+    height: 1in;
+
+    font-size: 10pt;
+}
+
+footer#foot {
+    position: running(pie);
+
+    margin: 0 -1in;
+    padding-top: 0cm;
+    padding-left: 1in;
+    padding-right: 1in;
+    padding-bottom: 1cm;
+
+    width: 100vw;
+    height: 1in;
+}
+
+.footer-container {
+    padding-top: 4mm;
+
+    font-size: 10pt;
+}
+
+.bold {
+    font-weight: bold;
+}
+
+.header-container {
+    padding-top: 5mm;
+    display: flex;
+    justify-content: space-between;
+    align-items: end;
+}
+
+.header-logo {
+    display: inline-block;
+    vertical-align: middle;
+    width: 2.8in !important;
+    height: auto !important;
+}
+
+.flex-between {
+    display: flex;
+    justify-content: space-between;
+}
+
+header#cabecera div span {
+    display: inline-block;
+    vertical-align: middle;
+    width: 200px;
+}
+
+
+
+body {
+    font-family: "Times New Roman", Times, serif;
+    font-size: 12pt;
+    line-height: 1.5;
+    color: #1a1a1a;
+    margin: 0;
+    padding: 0;
+}
+
+
+.title {
+    font-size: 16pt;
+    font-weight: bold;
+    text-align: center;
+    margin-bottom: 0.5cm;
+    line-height: 1.2;
+}
+
+.subtitle {
+    font-size: 12pt;
+    font-weight: bold;
+    text-transform: uppercase;
+    line-height: 1.2;
+}
+
+ol {
+    margin: 0;
+    padding: 0;
+}
+
+li {
+    margin-bottom: 6pt;
+}
+
+.text {
+    font-size: 11pt;
+    text-align: justify;
+    hyphens: auto;
+    line-height: 1.5;
+    overflow-wrap: anywhere;
+}
+
+.references {
+    font-size: 10pt;
+    text-align: justify;
+    hyphens: auto;
+    line-height: 1.5;
+    overflow-wrap: anywhere;
+}
+
+.keywords {
+    font-size: 11pt;
+    text-align: justify;
+    line-height: 1.2;
+}