BeyondCV 0.1.0__py3-none-any.whl

BeyondCV/LLM/CVFields.py

@@ -0,0 +1,82 @@
+BASE_TEMPLATE = {
+    "name": "Name",
+    "title": "Title",
+    "profile_summary": "summary",
+    "education": [
+        {"institute": "institute name", "degree": "degree name", "year": "year"}
+    ],
+    "experience": [
+        {
+            "organisation": "organisation name",
+            "job_title": "job title",
+            "job_period": "period",
+            "description": ["Experience bullet 1", "Experience bullet 2", "etc..."]
+        }
+    ],
+    "projects": [
+        {
+            "project_name": "Proj Name",
+            "period": "period",
+            "description": ["Bullet 1", "Bullet 2", "etc..."]
+        }
+    ],
+    "skill_groups": [
+        {"group_name": "Soft Skills", "items": ["Communication", "Problem Solving", "etc..."]},
+        {"group_name": "Programming Languages", "items": ["Python", "C", "C++"]},
+        {"group_name": "Software Tools", "items": ["CMake", "git", "Docker"]},
+        {"group_name": "Other Group", "items": ["item", "etc..."]},
+    ],
+    "languages": [
+        {"language": "Arabic", "proficiency": "Native"}
+    ],
+    "certifications": ["certification 1", "certification n.."]
+}
+
+EXTRA_MODULES = {
+    "salary": [
+        {
+            "key": "salary_expectation",
+            "description": "Candidate's stated salary expectation",
+            "type": "string"
+        }
+    ],
+    "military_status": [
+        {
+            "key": "military_status",
+            "description": "Candidtate's military status",
+            "type": "string"
+        }
+    ],
+    "social": [
+        {
+            "key": "linkedin",
+            "description": "LinkedIn profile URL",
+            "type": "string"
+        },
+        {
+            "key": "github",
+            "description": "GitHub profile URL",
+            "type": "string"
+        },
+        {
+            "key": "email",
+            "description": "Email",
+            "type": "string"
+        }
+    ]
+}
+
+
+def build_extra_fields_text(modules: list[str]) -> str:
+    """Builds the extra instruction block to append to the prompt."""
+    if not modules:
+        return ""
+
+    fields = [f for m in modules for f in EXTRA_MODULES.get(m, [])]
+    if not fields:
+        return ""
+
+    lines = ["Also extract the following additional fields:"]
+    for f in fields:
+        lines.append(f"- \"{f['key']}\": {f['description']} (type: {f['type']})")
+    return "\n".join(lines)

BeyondCV/LLM/LLMInvoker.py

@@ -0,0 +1,87 @@
+import json
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any
+
+from BeyondCV.LLM.utils import safe_parse_json, load_prompt
+from BeyondCV.config import bcv_config as cfg
+
+_always_use_cache: bool = bool(cfg.use_cache)  # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType]
+
+class LLMInvoker(ABC):
+    def __init__(self, path_to_pdf: str | Path, modules: list[str] | None = None) -> None:
+        self.pdf_path: str | Path = path_to_pdf
+        self.file_name: str = Path(path_to_pdf).stem
+
+        archive_path = self.get_default_archive_path()
+        if archive_path.exists():
+            if _always_use_cache:
+                use_cache = "yes"
+            else:
+                use_cache = input(
+                    f"Archived profile found for '{self.file_name}' at {archive_path}.\nUse cached version? [Y/n]: "
+                ).strip().lower()
+            if use_cache in ("", "y", "yes"):
+                with open(archive_path, "r") as f:
+                    self.result_json = json.load(f)
+                self.result_archive: str | Path = str(archive_path)  # pyright: ignore[reportRedeclaration]
+                print(f"Loaded profile from archive: {archive_path}")
+                return
+
+
+        print(f"Extracting data from '{path_to_pdf}'")
+
+        prompt: str = load_prompt(path_to_pdf, modules=modules)
+        self.result_json: Any = safe_parse_json(self.invoke(prompt))
+
+        print("Data retrieved.")
+
+        self.result_archive: str | Path = self.archive_json()
+
+    def get_archive_location(self) -> str | Path:
+        return self.result_archive
+
+    def get_result_json(self) -> Any:
+        return self.result_json
+
+
+    @abstractmethod
+    def invoke(self, prompt: str) -> str:
+        """
+        Prompts the LLM with the PDF and returns the json object as a string.
+        This function handles everything LLM related; from getting the prompt to prompting thr LLM and receiving the output.
+
+        Args:
+            prompt: The prompt to send to the LLM.
+
+        Returns:
+            Returns the LLM response text. Text sanitisation happens in the __init__ function.
+        """
+        pass
+
+    def get_default_archive_path(self) -> Path:
+        return Path.home() / ".beyondcv" / "archive" / f"{self.file_name}.json"
+
+    def archive_json(self) -> str | Path:
+        """
+        The JSON file is saved to an archive location and the location is returned.
+        This method can be overriden by the user to save to any location of their choice.
+
+        This method is automatically called by the __init__ function.
+        """
+        if not self.result_json:
+            raise ValueError("No JSON object available.")
+
+        json_archive: Path = self.get_default_archive_path()
+        json_archive.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(json_archive, "w") as f:
+            json.dump(self.result_json, f, indent=2, ensure_ascii=False)
+
+        print(f"Archived profile JSON in {json_archive}")
+        return json_archive
+
+
+__all__ = [
+    "LLMInvoker"
+]

BeyondCV/LLM/prompt.txt

@@ -0,0 +1,12 @@
+You are a CV parsing expert. Extract the following information from this CV and return it as a valid JSON object.
+Below is a template. Fill in the template with information from the CV attached. Do not make up any information. Only write what is written in the CV. Do not assume any information.
+If information cannot be found, leave it empty as such for example:
+  "projects": "",
+If, for example, only one experience exists then only include one experience section "experience": [{{}}] (<- GOOD) no extras; "experience": [{{}}, {{}}] (<- BAD)
+
+{json_template}
+{extra_fields}
+
+Return ONLY the JSON object, no additional text or markdown formatting.
+CV Text:
+{extracted_text}

BeyondCV/LLM/utils.py

@@ -0,0 +1,51 @@
+import json
+import pypdf
+from pathlib import Path
+from typing import Any
+from BeyondCV.LLM.CVFields import BASE_TEMPLATE, build_extra_fields_text
+
+
+def extract_text_from_pdf(pdf_path: str | Path) -> str:
+    """
+    Extract text content from a PDF file.
+    
+    Args:
+        pdf_path: Path to the PDF file
+        
+    Returns:
+        Extracted text as a string
+    """
+    with open(pdf_path, 'rb') as file:
+        pdf_reader = pypdf.PdfReader(file)
+        text = ""
+        for page in pdf_reader.pages:
+            text += page.extract_text()
+    return text
+
+
+def load_prompt(path_to_pdf: str | Path, modules: list[str] | None = None) -> str:
+    if not modules: modules = []
+
+    prompt_path = Path(__file__).parent / "prompt.txt"
+
+    with open(prompt_path, "r") as p:
+        prompt_template = p.read()
+
+    return prompt_template.format(
+        json_template=json.dumps(BASE_TEMPLATE, indent=2),
+        extra_fields=build_extra_fields_text(modules),
+        extracted_text=extract_text_from_pdf(path_to_pdf),
+    )
+
+
+def safe_parse_json(response_text: str) -> Any:
+    """Parse JSON from LLM response, handling markdown fences if present."""
+    if not response_text:
+        raise ValueError("Response is empty")
+    try:
+        return json.loads(response_text)
+    except json.JSONDecodeError:
+        import re
+        cleaned = re.sub(r"^```(?:json)?\s*|\s*```$", "", response_text.strip())
+        return json.loads(cleaned)
+

BeyondCV/TableBuilder/Table.py

@@ -0,0 +1,136 @@
+__all__ = [
+    "CellConfig",
+    "ParagraphConfig",
+    "Paragraph",
+    "Cell",
+    "Row",
+    "Table"
+]
+
+from colour import Color
+from BeyondCV.config import bcv_config as cfg
+from BeyondCV.utils import PaperDimensions, get_paper_dimensions, get_page_dimensions
+
+_default_alignment: dict[str, str] = {
+    "vertical": "center",       # Can be "top", "center", "bottom"
+    "horizontal": "left",     # Can be "left", "center", "right"
+}
+
+# Paper imensions are that of the whole paper
+_paper_dimensions: PaperDimensions = get_paper_dimensions(str(cfg.paper_size).lower())  # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType]
+# Page dimensions are that of the space within the margins
+_page_dimensions: PaperDimensions = get_page_dimensions(
+    _paper_dimensions,
+    float(cfg.margin_left_cm), float(cfg.margin_right_cm),  # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType]
+    float(cfg.margin_top_cm), float(cfg.margin_bottom_cm)   # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType]
+)
+
+
+class CellConfig:
+    def __init__(
+        self,
+        width_cm: float = 0.0,       # If width is 0.0, the with of the cell is set to 1/total row width
+        color: Color | None = None,
+        content_alignment: dict[str, str] = _default_alignment,
+        show_borders: bool = False
+    ):
+        self.width_cm: float = width_cm
+        self.color: Color | None = color
+        self.content_alignment: dict[str, str] = content_alignment
+        self.show_borders: bool = show_borders
+
+
+class ParagraphConfig:
+    def __init__(
+        self,
+        font_name: str = cfg.default_font,  # pyright: ignore[reportUnknownMemberType]
+        font_size_pt: float = 10.0,
+        bold: bool = False,
+        italic: bool = False,
+        underline: bool = False,
+        bullet: bool = False
+    ):
+        self.font_name: str = font_name
+        self.font_size_pt: float = font_size_pt
+        self.bold: bool = bold
+        self.italic: bool = italic
+        self.underline: bool = underline
+        self.bullet: bool = bullet
+
+
+class Paragraph:
+    def __init__(
+        self,
+        text: str,
+        config: ParagraphConfig | None = None
+    ):
+        self.text: str = text
+        self.config: ParagraphConfig = config if config else ParagraphConfig()
+
+
+class Cell:
+    def __init__(
+        self,
+        content: list[Paragraph] | Paragraph,
+        config: CellConfig | None = None
+    ):
+        self.paragraphs: list[Paragraph] = [content] if isinstance(content, Paragraph) else content
+        self.config: CellConfig = config if config else CellConfig()
+
+
+class Row:
+    def __init__(
+        self,
+        cells: list[Cell] | Cell,
+        min_height_cm: float = 0.45,
+        row_width_cm: float = 0.0           # If this value is 0, the row is as wide as the page margins
+    ):
+        self.cells: list[Cell] = [cells] if isinstance(cells, Cell) else cells
+        self.row_width_cm: float = row_width_cm if row_width_cm > 0.0 else _page_dimensions.width
+        self.min_height_cm: float = min_height_cm
+
+        for cell in self.cells:
+            if cell.config.width_cm <= 0.0:
+                cell.config.width_cm = self.row_width_cm * (1/len(self.cells))
+ 
+    def add_cell(self, cell: Cell):
+        self.cells.append(cell)
+
+
+class Column:
+    def __init__(
+        self,
+        cells: list[Cell],
+        min_height_cm: float = 0.45,
+        width_cm: float = 0.0,      # Again, if this value is zero, width is calculated at runtime depending on the number of columns in the table
+    ):
+        self.cells: list[Cell] = cells
+        self.min_height_cm: float = min_height_cm
+        self.width_cm: float = width_cm
+
+
+class Table:
+    def __init__(
+        self,
+        content: list[Row] | list[Column]
+    ):
+        self.content: list[Row] | list[Column] = content
+        
+        if Table.are_columns(self.content) and len(self.content) > 0:
+            for col in self.content:
+                col.width_cm = 1/len(self.content) * _page_dimensions.width  # pyright: ignore[reportAttributeAccessIssue]
+        
+    @staticmethod
+    def are_columns(items: list[Row] | list[Column]):
+        for i in items:
+            if not isinstance(i, Column):
+                return False
+        return True
+
+    @staticmethod
+    def are_rows(items: list[Row] | list[Column]):
+        for i in items:
+            if not isinstance(i, Row):
+                return False
+        return True
+

BeyondCV/TableBuilder/__init__.py

@@ -0,0 +1,10 @@
+from BeyondCV.TableBuilder.Table import *
+
+__all__ = [
+    "CellConfig",
+    "ParagraphConfig",
+    "Paragraph",
+    "Cell",
+    "Row",
+    "Table"
+]

BeyondCV/Template/Template.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+__all__ = [
+    "CVTemplate",
+    "Section",
+    "RepeatingSection",
+]
+
+import copy
+import re
+from typing import Any
+
+from BeyondCV.TableBuilder.Table import Cell, Paragraph, ParagraphConfig, Row, Table
+
+
+class SectionBase:
+    def _resolve_row(self, row: Row, data: dict[str, Any]) -> Row:
+        resolved_cells: list[Cell] = []
+        for cell in row.cells:
+            resolved_paragraphs: list[Paragraph] = []
+            for p in cell.paragraphs:
+                resolved = SectionBase._resolve_placeholders(p.text, data)
+                if isinstance(resolved, list):
+                    resolved_paragraphs.extend(
+                        Paragraph(item, copy.deepcopy(p.config)) for item in resolved
+                    )
+                else:
+                    resolved_paragraphs.append(Paragraph(resolved, copy.deepcopy(p.config)))
+            resolved_cells.append(Cell(resolved_paragraphs, copy.deepcopy(cell.config)))
+        return Row(resolved_cells, row.min_height_cm, row.row_width_cm)
+
+
+    @staticmethod
+    def _resolve_placeholders(text: str, data: dict[str, Any]) -> str | list[str]:
+        """
+        Replace {field_name} placeholders in a text string with values from the data dict.
+
+        When a field holds a list value (e.g. description = ["bullet1", "bullet2"]),
+        the entire function returns a list of strings instead, so the caller can
+        create one Paragraph per list item.
+
+        If the template text contains a suffix immediately after the list placeholder
+        (e.g. "{items},"), the suffix is appended to every item except the last.
+
+        Args:
+            text: A string that may contain {field_name} placeholders.
+            data: The data dict to resolve placeholders against.
+
+        Returns:
+            The resolved string, or a list of strings if the field value was a list.
+        """
+        _PLACEHOLDER_RE = re.compile(r"\{(\w+)\}")
+
+        def _replace(match: re.Match[str]) -> str:
+            key: str = match.group(1)
+            value: str | list[str] | None = data.get(key)
+            if value is None:
+                return match.group(0)
+            if isinstance(value, list):
+                return "<__LIST_PLACEHOLDER__>"
+            return str(value)
+
+        resolved = _PLACEHOLDER_RE.sub(_replace, text)
+        if "<__LIST_PLACEHOLDER__>" in resolved:
+            keys = [m.group(1) for m in _PLACEHOLDER_RE.finditer(text)]
+            for k in keys:
+                v: Any | None = data.get(k)
+                if isinstance(v, list):
+                    # Extract any suffix that follows the {key} placeholder in the template.
+                    suffix_match = re.search(r"\{" + re.escape(k) + r"\}(.*)$", text)
+                    suffix = suffix_match.group(1) if suffix_match else ""
+                    items = [str(item) for item in v]                    # pyright: ignore[reportUnknownArgumentType, reportUnknownVariableType]
+                    if suffix:
+                        return [item + suffix for item in items[:-1]] + [items[-1]]
+                    return items
+            return resolved.replace("<__LIST_PLACEHOLDER__>", "")
+        return resolved
+
+
+class SectionTitle:
+    def __init__(self, title: str, text_config: ParagraphConfig | None = None):
+        if text_config == None:
+            text_config = ParagraphConfig(font_size_pt=15, bold=True)
+
+        self.table: Table = Table([
+            Row(Cell([Paragraph(title, config=text_config)]))
+        ])
+
+
+class Section(SectionBase):
+    def __init__(
+        self,
+        *rows: Row,
+        title: SectionTitle | None = None
+    ):
+        self.rows: list[Row] = list(rows)
+        self.title: SectionTitle | None = title
+
+    def build(self, data: dict[str, Any]) -> list[Table]:
+        resolved_rows = [self._resolve_row(row, data) for row in self.rows]
+        return [Table(resolved_rows)] if not self.title else [self.title.table, Table(resolved_rows)]
+
+
+class RepeatingSection(SectionBase):
+    def __init__(
+        self,
+        source_key: str,
+        item: Table,
+        header: list[Row] | Row | None = None,
+        title: SectionTitle | None = None
+    ):
+        self.source_key: str = source_key
+        self.item: Table = item
+        self.header: list[Row] = [header] if isinstance(header, Row) else header or []
+        self.title: SectionTitle | None = title
+
+    def build(self, data: dict[str, Any]) -> list[Table]:
+        items: list[Any] | str = data.get(self.source_key, [])
+        if not isinstance(items, list):
+            items = [items]
+
+        result: list[Table] = [] if not self.title else [self.title.table]
+        if not self.header:
+            return [*result, *self._build_separate(items)]
+        else:
+            return [*result, *self._build_with_header(items, data)]
+
+    def _build_separate(self, items: list[Any]) -> list[Table]:
+        tables: list[Table] = []
+        for item_data in items:
+            if not isinstance(item_data, dict):
+                tables.append(copy.deepcopy(self.item))
+                continue
+
+            resolved_rows: list[Row] = []
+            for row in self.item.content:
+                if isinstance(row, Row):
+                    resolved_rows.append(self._resolve_row(row, item_data))          # pyright: ignore[reportUnknownArgumentType]
+            tables.append(Table(resolved_rows))
+
+        return tables
+
+    def _build_with_header(self, items: list[Any], data: dict[str, Any]) -> list[Table]:
+        resolved_rows: list[Row] = []
+        for row in self.header:
+            resolved_rows.append(self._resolve_row(row, data))
+
+        for item_data in items:
+            if not isinstance(item_data, dict):
+                for row in self.item.content:
+                    if isinstance(row, Row):
+                        resolved_rows.append(copy.deepcopy(row))
+                continue
+
+            for row in self.item.content:
+                if isinstance(row, Row):
+                    resolved_rows.append(self._resolve_row(row, item_data))          # pyright: ignore[reportUnknownArgumentType]
+
+        return [Table(resolved_rows)]
+
+
+class CVTemplate:
+    def __init__(self, sections: list[Section | RepeatingSection]):
+        self.sections: list[Section | RepeatingSection] = sections
+
+    def build(self, data: dict[str, Any]) -> list[Table]:
+        tables: list[Table] = []
+        for section in self.sections:
+            tables.extend(section.build(data))
+        return tables

BeyondCV/Template/__init__.py

@@ -0,0 +1,7 @@
+from BeyondCV.Template.Template import CVTemplate, Section, RepeatingSection
+
+__all__ = [
+    "CVTemplate",
+    "Section",
+    "RepeatingSection",
+]

BeyondCV/Translator/DocTranslator.py

@@ -0,0 +1,39 @@
+from abc import ABC, abstractmethod
+from typing import Any
+from pathlib import Path
+from BeyondCV.Template import CVTemplate
+
+
+class DocTranslator(ABC):
+    def __init__(self, document_name: str, template: CVTemplate):
+        """
+        Intialises the translator, making sure the save location exists.
+        Args:
+            document_name: Name of the output document. This MUST contain the file extension so that the file is correcly saved.
+            template: The CV template created that will be translated. 
+        """
+        if not Path(document_name).suffix:
+            raise ValueError(f"document_name must include a file extension (e.g. 'my_cv.docx'), got: '{document_name}'")
+
+        doc_location: Path = Path.home() / ".beyondcv" / "outfiles" / f"{document_name}"
+        doc_location.parent.mkdir(parents=True, exist_ok=True)
+        self._doc_location: Path = doc_location
+        self._template: CVTemplate = template
+
+    @abstractmethod
+    def build(self, data: dict[str, Any]) -> str:
+        """
+        A method uniquely implemented for each filetype. This method should build the document and return the path to this newly built document.
+
+        Args:
+            data: The data about the profile as a json object.
+
+        Returns:
+            The location of the newly created document.
+        """
+        pass
+
+
+__all__ = [
+    "DocTranslator",
+]

BeyondCV/Translator/DocxTranslator.py

@@ -0,0 +1,214 @@
+from typing import Any, override
+
+from docx import Document
+from docx.document import Document as DocType
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from docx.oxml import OxmlElement  # pyright: ignore[reportUnknownVariableType]
+from docx.oxml.ns import qn
+from docx.oxml.table import CT_TcPr
+from docx.shared import Cm, Pt
+from docx.table import _Cell as DocxCell, Table as DocxTable  # pyright: ignore[reportPrivateUsage]
+from docx.text.paragraph import Paragraph as DocxParagraph
+
+from colour import Color
+
+from BeyondCV.Translator.DocTranslator import DocTranslator
+from BeyondCV.TableBuilder.Table import Table as CVTable, Row, Cell, Paragraph, Column
+from BeyondCV.config import bcv_config as cfg
+
+
+class DocxTranslator(DocTranslator):
+    _HALIGN_MAP: dict[str, WD_ALIGN_PARAGRAPH] = {
+        "left": WD_ALIGN_PARAGRAPH.LEFT,
+        "center": WD_ALIGN_PARAGRAPH.CENTER,
+        "right": WD_ALIGN_PARAGRAPH.RIGHT,
+    }
+
+    @override
+    def build(self, data: dict[str, Any]) -> str:
+        tables = self._template.build(data)
+        doc: DocType = Document()
+
+        for section in doc.sections:
+            section.top_margin = Cm(float(cfg.margin_top_cm))           # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType]
+            section.bottom_margin = Cm(float(cfg.margin_bottom_cm))     # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType]
+            section.left_margin = Cm(float(cfg.margin_left_cm))         # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType]
+            section.right_margin = Cm(float(cfg.margin_right_cm))       # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType]
+
+        for i, table_model in enumerate(tables):
+            if i > 0:
+                _ = doc.add_paragraph()
+            self._add_table(doc, table_model)
+
+        doc.save(str(self._doc_location))
+        return str(self._doc_location)
+
+    # ------------------------------------------------------------------ #
+    #  Table rendering
+    # ------------------------------------------------------------------ #
+
+    def _add_table(self, doc: DocType, table_model: CVTable):
+        if CVTable.are_columns(table_model.content):
+            self._add_column_table(doc, table_model)
+        else:
+            self._add_row_table(doc, table_model)
+
+    def _add_row_table(self, doc: DocType, table_model: CVTable):
+        rows = [r for r in table_model.content if isinstance(r, Row)]
+        if not rows:
+            return
+
+        max_cols = max(len(r.cells) for r in rows)
+        table = doc.add_table(rows=len(rows), cols=max_cols)
+        self._remove_table_borders(table)
+
+        for row_idx, row_model in enumerate(rows):
+            table.rows[row_idx].height = Cm(row_model.min_height_cm)
+
+            for col_idx, cell_model in enumerate(row_model.cells):
+                cell = table.cell(row_idx, col_idx)
+                self._fill_cell(cell, cell_model)
+
+            if len(row_model.cells) < max_cols:
+                start = table.cell(row_idx, len(row_model.cells) - 1)
+                end = table.cell(row_idx, max_cols - 1)
+                _ = start.merge(end)
+
+    def _add_column_table(self, doc: DocType, table_model: CVTable):
+        columns = [c for c in table_model.content if isinstance(c, Column)]
+        if not columns:
+            return
+
+        col_count = len(columns)
+        row_count = max(len(c.cells) for c in columns)
+        if row_count == 0:
+            return
+
+        table = doc.add_table(rows=row_count, cols=col_count)
+        self._remove_table_borders(table)
+
+        for col_idx, col_model in enumerate(columns):
+            for row_idx, cell_model in enumerate(col_model.cells):
+                cell = table.cell(row_idx, col_idx)
+                self._fill_cell(cell, cell_model)
+
+    # ------------------------------------------------------------------ #
+    #  Cell / Paragraph formatting
+    # ------------------------------------------------------------------ #
+
+    def _fill_cell(self, cell: DocxCell, cell_model: Cell):
+        config = cell_model.config
+
+        if config.width_cm > 0.0:
+            cell.width = Cm(config.width_cm)
+
+        self._set_cell_vertical_alignment(cell, config.content_alignment.get("vertical", "center"))
+
+        self._remove_cell_shading(cell)
+        if config.color is not None:
+            self._set_cell_shading(cell, config.color)
+
+        self._remove_cell_borders(cell)
+        if config.show_borders:
+            self._set_cell_borders(cell)
+
+        for para_idx, para_model in enumerate(cell_model.paragraphs):
+            p = cell.paragraphs[0] if para_idx == 0 else cell.add_paragraph()
+            _ = p.clear()
+            self._format_paragraph(p, para_model, config.content_alignment)
+
+    def _format_paragraph(self, p: DocxParagraph, para_model: Paragraph, alignment: dict[str, str]):
+        p.paragraph_format.space_before = Pt(0)
+        p.paragraph_format.space_after = Pt(0)
+
+        halign = alignment.get("horizontal", "left")
+        p.alignment = self._HALIGN_MAP.get(halign, WD_ALIGN_PARAGRAPH.LEFT)
+
+        if para_model.config.bullet:
+            p.style = "List Bullet"
+
+        run = p.add_run(para_model.text)
+        run.font.name = para_model.config.font_name
+        run.font.size = Pt(para_model.config.font_size_pt)
+        run.bold = para_model.config.bold
+        run.italic = para_model.config.italic
+        run.underline = para_model.config.underline
+
+    # ------------------------------------------------------------------ #
+    #  XML helpers — vertical alignment
+    # ------------------------------------------------------------------ #
+
+    @staticmethod
+    def _set_cell_vertical_alignment(cell: DocxCell, valign: str):
+        tc = cell._tc  # pyright: ignore[reportPrivateUsage]
+        tcPr: CT_TcPr = tc.get_or_add_tcPr()
+        existing = tcPr.find(qn("w:vAlign"))
+        if existing is not None:
+            tcPr.remove(existing)
+        elem = OxmlElement("w:vAlign")
+        elem.set(qn("w:val"), valign)
+        tcPr.append(elem)
+
+    # ------------------------------------------------------------------ #
+    #  XML helpers — shading / background colour
+    # ------------------------------------------------------------------ #
+
+    @staticmethod
+    def _remove_cell_shading(cell: DocxCell):
+        tc = cell._tc       # pyright: ignore[reportPrivateUsage]
+        tcPr = tc.get_or_add_tcPr()
+        for shd in tcPr.findall(qn("w:shd")):
+            tcPr.remove(shd)
+
+    @staticmethod
+    def _set_cell_shading(cell: DocxCell, color: Color):
+        hex_color = color.hex_l[1:]
+        tc = cell._tc       # pyright: ignore[reportPrivateUsage]
+        tcPr = tc.get_or_add_tcPr()
+        shd = OxmlElement("w:shd")
+        shd.set(qn("w:fill"), hex_color)
+        shd.set(qn("w:val"), "clear")
+        tcPr.append(shd)
+
+    # ------------------------------------------------------------------ #
+    #  XML helpers — borders
+    # ------------------------------------------------------------------ #
+
+    @staticmethod
+    def _remove_cell_borders(cell: DocxCell):
+        tc = cell._tc       # pyright: ignore[reportPrivateUsage]
+        tcPr = tc.get_or_add_tcPr()
+        existing = tcPr.find(qn("w:tcBorders"))
+        if existing is not None:
+            tcPr.remove(existing)
+
+    @staticmethod
+    def _set_cell_borders(cell: DocxCell):
+        tc = cell._tc       # pyright: ignore[reportPrivateUsage]
+        tcPr = tc.get_or_add_tcPr()
+        borders = OxmlElement("w:tcBorders")
+        for side in ("top", "left", "bottom", "right"):
+            border = OxmlElement(f"w:{side}")
+            border.set(qn("w:val"), "single")
+            border.set(qn("w:sz"), "4")
+            border.set(qn("w:space"), "0")
+            border.set(qn("w:color"), "000000")
+            borders.append(border)
+        tcPr.append(borders)
+
+    @staticmethod
+    def _remove_table_borders(table: DocxTable):
+        tbl = table._tbl        # pyright: ignore[reportPrivateUsage]
+        tblPr = tbl.find(qn("w:tblPr"))
+        if tblPr is None:
+            tblPr = OxmlElement("w:tblPr")
+            tbl.insert(0, tblPr)
+        borders = OxmlElement("w:tblBorders")
+        for side in ("top", "left", "bottom", "right", "insideH", "insideV"):
+            border = OxmlElement(f"w:{side}")
+            border.set(qn("w:val"), "none")
+            border.set(qn("w:sz"), "0")
+            border.set(qn("w:space"), "0")
+            border.set(qn("w:color"), "auto")
+            borders.append(border)
+        tblPr.append(borders)

BeyondCV/Translator/TeXTranslator.py

@@ -0,0 +1,7 @@
+from typing import override, Any
+from BeyondCV.Translator.DocTranslator import DocTranslator
+
+class TeXTranslator(DocTranslator):
+    @override
+    def build(self, data: dict[str, Any]) -> str:
+        pass

BeyondCV/Translator/__init__.py

@@ -0,0 +1,7 @@
+from BeyondCV.Translator.DocxTranslator import DocxTranslator
+from BeyondCV.Translator.TeXTranslator import TeXTranslator
+
+__all__ = [
+    "DocxTranslator",
+    "TeXTranslator"
+]

BeyondCV/config.py

@@ -0,0 +1,30 @@
+"""
+In this file, the CV template proprties can be configured.
+"""
+
+__all__ = [
+    "bcv_config"
+]
+
+import yaml
+from pathlib import Path
+from addict import Dict
+from BeyondCV.utils import merge_dicts_recursively
+
+
+def _load_yaml(file_path: str | Path) -> dict[str, str]:
+    try:
+        with open(file_path, "r") as file:
+            return yaml.safe_load(file) or {}
+    except FileNotFoundError:
+        return {}
+
+
+default_config_dir = Path(__file__).resolve().parent / "default_config.yaml"
+current_config_dir = "current_config.yaml"
+
+# ORDER MATTERS! Ensure current_config exists AFTER default_config
+bcv_config: Dict = Dict(merge_dicts_recursively(
+    _load_yaml(default_config_dir),
+    _load_yaml(current_config_dir)
+))

BeyondCV/default_config.yaml

@@ -0,0 +1,7 @@
+paper_size: "A4"    # Can be "A4" or "letter"
+margin_top_cm: 2.54
+margin_bottom_cm: 2.54
+margin_right_cm: 2.54
+margin_left_cm: 2.54
+default_font: "Aptos"
+use_cache: false

BeyondCV/utils.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+__all__ = [
+    "PaperDimensions",
+    "merge_dicts_recursively",
+    "get_page_dimensions",
+    "get_paper_dimensions",
+]
+
+
+import itertools as it
+from typing import Any, NamedTuple
+
+class PaperDimensions(NamedTuple):
+    width: float
+    height: float
+
+
+# Taken from https://github.com/3b1b/manim/blob/master/manimlib/utils/dict_ops.py
+def merge_dicts_recursively(*dicts: dict[Any, Any]) -> dict[Any, Any]:
+    """
+    Creates a dict whose keyset is the union of all the
+    input dictionaries.  The value for each key is based
+    on the first dict in the list with that key.
+
+    dicts later in the list have higher priority
+
+    When values are dictionaries, it is applied recursively
+    """
+    result: dict[Any, Any] = dict()
+    all_items = it.chain(*[d.items() for d in dicts])
+    for key, value in all_items:
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = merge_dicts_recursively(result[key], value)  # pyright: ignore[reportUnknownArgumentType]
+        else:
+            result[key] = value
+    return result
+
+
+def get_paper_dimensions(paper_size: str = "a4") -> PaperDimensions:
+    if paper_size == "letter":
+        return PaperDimensions(21.6, 27.9)
+    else:
+        return PaperDimensions(21.0, 29.7)
+
+
+def get_page_dimensions(paper_dims: PaperDimensions, margin_left_cm: float, margin_right_cm: float, margin_top_cm: float, margin_bottom_cm: float):
+    return PaperDimensions(
+        paper_dims.width - margin_left_cm - margin_right_cm,
+        paper_dims.height - margin_top_cm - margin_bottom_cm
+    )
+
+

beyondcv-0.1.0.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: BeyondCV
+Version: 0.1.0
+Summary: A CV builder.
+Author: Abdallah Soliman
+Author-email: Abdallah Soliman <abdallahsoliman03@gmail.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Dist: addict>=2.4.0
+Requires-Dist: colour>=0.1.5
+Requires-Dist: debugpy>=1.8.20
+Requires-Dist: dotenv>=0.9.9
+Requires-Dist: openai>=2.36.0
+Requires-Dist: pypdf>=6.11.0
+Requires-Dist: python-docx>=1.2.0
+Requires-Dist: pyyaml>=6.0.3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# BeyondCV
+No more pressing CTRL+C, CTRL+V to put your CV into a new template.
+
+<!--toc:start-->
+- [Introduction](#introduction)
+- [Architecture](#architecture)
+- [License](#license)
+- [Disclaimer](#disclaimer)
+<!--toc:end-->
+
+## Introduction
+This is a tool used to quickly move an existing CV/resume from one template to another.
+Drop in the old CV, configure the output template and get the new CV.
+
+This tool is best used to mass convert CVs, for inidvidual CVs, this may not be the best option as the
+CV template may be less configurable than one made manually.
+
+This project has two different parts to it:
+1. BeyondCV: the library used to create a CV builder, providing a framework to follow.
+2. BuildImpl: an implementation using BeyondCV to create a full CV conversion pipeline.
+
+## How To Use
+See the [BuildImpl](/BuildImpl/) file for a sample implementation.
+
+## Architecture
+See the [Architecture](/Architecture.md) document for more info.
+
+## License
+See [LICENSE](/LICENSE) document.
+
+## Disclaimer
+This code was partly generated by AI, so there may be some bugs.

beyondcv-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+BeyondCV/LLM/CVFields.py,sha256=9bHZ18ZGYamUZrddibm4emva_bK0y0KWhGU3cBnEbsg,2459
+BeyondCV/LLM/LLMInvoker.py,sha256=MdqOMFAwCoecOzLNTJILu1RAiLuStmWAhQ2giy9KzxQ,3158
+BeyondCV/LLM/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+BeyondCV/LLM/prompt.txt,sha256=k9Lh6fsO7Ku9Iv871CVW0rlg0ZWcpLYg_ZsRvYiKopw,688
+BeyondCV/LLM/utils.py,sha256=0XydHhlkupIw9el8bK6pFliOk6zKnSn6IwvecMWPPKI,1498
+BeyondCV/TableBuilder/Table.py,sha256=4iaWhEGbEVnmnvYQp_30r4g55clnd0Yd7MFJSl07PYc,4600
+BeyondCV/TableBuilder/__init__.py,sha256=rORvLB5tp3jrOmYpzY_JB67YxDHHFZU2_8IRR7IH0Gc,160
+BeyondCV/Template/Template.py,sha256=FQa4ziXGHlcd2s77rNA991HiD4ULix502wj2H9GWyME,6682
+BeyondCV/Template/__init__.py,sha256=GkzINbj7aYVFVlRPorMLs-1K5QPtY_TDupVpcYI49Iw,154
+BeyondCV/Translator/DocTranslator.py,sha256=m7sIA-43J64gaI5LRPEQMcq9_AXxSZxx2o3wtSBzgag,1423
+BeyondCV/Translator/DocxTranslator.py,sha256=JFIEv7lsgdIIt9XUOuMSu5g-BamPzAi26Qs9uKn_w1E,8785
+BeyondCV/Translator/TeXTranslator.py,sha256=t7cCEGyCEBYyBhWK8CRP-tsAkERcWpzBWHN2YkA46fQ,214
+BeyondCV/Translator/__init__.py,sha256=g4oNIJ9CUJl9HloQwyiAM_5p9OAlx_iKi3JOpM_qx9k,186
+BeyondCV/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+BeyondCV/config.py,sha256=b2WrLpa3-VmNlDlFtV3YXKTStPL7992Q0xK1zaPWft8,760
+BeyondCV/default_config.yaml,sha256=qcvgE71U_vCISouFGzyavmPg3xqXqJtT1-jLMUJxSZ8,178
+BeyondCV/utils.py,sha256=8SdCz-cJaz3Ow7XUcW1O2U_Tw5uajzWBRG_DMNpDogI,1684
+beyondcv-0.1.0.dist-info/licenses/LICENSE,sha256=NhwhbwmIgo8AFh5O1g9ctPGkLN6hDdf_Dqv2gYAybhY,11053
+beyondcv-0.1.0.dist-info/WHEEL,sha256=XkDrRXQq-qVsrKMtsDUOHeLkiG7UK4Ds0JuG05OqKU4,81
+beyondcv-0.1.0.dist-info/METADATA,sha256=S19zqD3sAtBhy7PI_bHPZNqBf-tbODfnp_fOgQc48qQ,1627
+beyondcv-0.1.0.dist-info/RECORD,,

beyondcv-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.13
+Root-Is-Purelib: true
+Tag: py3-none-any

beyondcv-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+