Spaces:
Sleeping
Sleeping
| import re | |
| import pdfplumber | |
| # Section keywords to detect standard resume sections | |
| SECTION_KEYWORDS = { | |
| "experience": ["experience", "work experience", "employment", "work history"], | |
| "education": ["education", "academic background", "qualifications"], | |
| "skills": ["skills", "technical skills", "core competencies", "expertise"], | |
| "summary": ["summary", "objective", "profile", "about me"], | |
| "contact": ["contact", "personal information", "personal details"], | |
| "projects": ["projects", "personal projects", "key projects"], | |
| "certifications": ["certifications", "certificates", "licenses"], | |
| } | |
| def extract_resume_from_stream(stream) -> dict: | |
| """ | |
| Opens a PDF with pdfplumber from a stream, extracts text page by page, | |
| detects basic metadata, and identifies resume sections. | |
| """ | |
| text_pages = [] | |
| hidden_pages = [] | |
| has_tables = False | |
| has_images = False | |
| page_count = 0 | |
| font_names = set() | |
| font_sizes = [] | |
| has_multiple_columns = False | |
| with pdfplumber.open(stream) as pdf: | |
| page_count = len(pdf.pages) | |
| for page in pdf.pages: | |
| # Detect tables | |
| if page.find_tables(): | |
| has_tables = True | |
| # Detect images | |
| if page.images: | |
| has_images = True | |
| has_multiple_columns = has_multiple_columns or _detect_multiple_columns(page) | |
| for char in page.chars: | |
| font_name = _normalize_font_name(str(char.get("fontname", ""))) | |
| if font_name: | |
| font_names.add(font_name) | |
| size = char.get("size") | |
| if isinstance(size, (int, float)) and size > 0: | |
| font_sizes.append(float(size)) | |
| page_text, page_hidden = _split_hidden(page) | |
| if page_hidden: | |
| hidden_pages.append(page_hidden) | |
| if _is_sparse_page_text(page_text, page): | |
| page_text = _extract_words_as_lines(page) or page_text | |
| text_pages.append(page_text) | |
| full_text = "\n".join(text_pages).strip() | |
| hidden_text = "\n".join(hidden_pages).strip() | |
| # Confidence: penalise if text is very short relative to page count | |
| expected_min_chars = page_count * 200 | |
| confidence = min(1.0, len(full_text) / max(expected_min_chars, 1)) | |
| confidence = round(confidence, 2) | |
| sections = _detect_sections(full_text) | |
| non_empty_lines = [line.strip() for line in full_text.splitlines() if line.strip()] | |
| long_line_count = sum(len(line) > 120 for line in non_empty_lines) | |
| bullet_count = sum( | |
| bool(re.match(r"^[\u2022\u25e6\u25aa\u25cf\-\u2013\u2014*]\s+", line)) | |
| for line in non_empty_lines | |
| ) | |
| return { | |
| "text": full_text, | |
| "sections": sections, | |
| "metadata": { | |
| "hasTables": has_tables, | |
| "hasImages": has_images, | |
| "pageCount": page_count, | |
| "confidence": confidence, | |
| "hasMultipleColumns": has_multiple_columns, | |
| "fontCount": len(font_names), | |
| "minFontSize": round(min(font_sizes), 1) if font_sizes else None, | |
| "averageFontSize": round(sum(font_sizes) / len(font_sizes), 1) if font_sizes else None, | |
| "averageCharsPerPage": round(len(full_text) / max(page_count, 1)), | |
| "longLineCount": long_line_count, | |
| "bulletCount": bullet_count, | |
| # Text the page draws but nobody can read. The backend treats this | |
| # as a high-severity integrity finding rather than as CV content: | |
| # skills only present here were written for the scorer, not for the | |
| # person doing the hiring. | |
| "hiddenTextFound": bool(hidden_text), | |
| "hiddenTextSample": hidden_text[:300] or None, | |
| }, | |
| } | |
| def extract_docx_from_stream(stream) -> dict: | |
| """Extract ordered text and layout signals from a DOCX document.""" | |
| from docx import Document | |
| from docx.oxml.ns import qn | |
| document = Document(stream) | |
| text_lines = [] | |
| hidden_runs = [] | |
| font_names = set() | |
| font_sizes = [] | |
| for paragraph in document.paragraphs: | |
| # Word has a literal hidden-text attribute (w:vanish) as well as the | |
| # white-on-white trick, and python-docx exposes both. A run hidden by | |
| # either is dropped from the text and kept as evidence: it is not | |
| # content the candidate is showing the employer. | |
| visible_runs = [] | |
| for run in paragraph.runs: | |
| if _is_hidden_run(run): | |
| if run.text.strip(): | |
| hidden_runs.append(run.text.strip()) | |
| continue | |
| visible_runs.append(run) | |
| if run.font.name: | |
| font_names.add(_normalize_font_name(run.font.name)) | |
| if run.font.size: | |
| font_sizes.append(float(run.font.size.pt)) | |
| text = ("".join(run.text for run in visible_runs) or paragraph.text).strip() | |
| if hidden_runs and not visible_runs: | |
| text = "" | |
| if text: | |
| text_lines.append(text) | |
| for table in document.tables: | |
| for row in table.rows: | |
| cells = [cell.text.strip() for cell in row.cells if cell.text.strip()] | |
| if cells: | |
| text_lines.append(" | ".join(cells)) | |
| full_text = "\n".join(text_lines).strip() | |
| hidden_text = "\n".join(hidden_runs).strip() | |
| estimated_pages = max(1, round(len(full_text) / 3500)) | |
| has_multiple_columns = False | |
| for section in document.sections: | |
| columns = section._sectPr.xpath('./w:cols') | |
| if columns: | |
| count = columns[0].get(qn('w:num')) | |
| if count and int(count) > 1: | |
| has_multiple_columns = True | |
| long_line_count = sum(len(line) > 120 for line in text_lines) | |
| bullet_count = sum( | |
| bool(re.match(r"^[\u2022\u25e6\u25aa\u25cf\-\u2013\u2014*]\s+", line)) | |
| for line in text_lines | |
| ) | |
| confidence = 1.0 if len(full_text) >= 100 else round(len(full_text) / 100, 2) | |
| return { | |
| "text": full_text, | |
| "sections": _detect_sections(full_text), | |
| "metadata": { | |
| "hasTables": bool(document.tables), | |
| "hasImages": bool(document.inline_shapes), | |
| "pageCount": estimated_pages, | |
| "confidence": confidence, | |
| "hasMultipleColumns": has_multiple_columns, | |
| "fontCount": len(font_names), | |
| "minFontSize": round(min(font_sizes), 1) if font_sizes else None, | |
| "averageFontSize": round(sum(font_sizes) / len(font_sizes), 1) if font_sizes else None, | |
| "averageCharsPerPage": round(len(full_text) / estimated_pages), | |
| "longLineCount": long_line_count, | |
| "bulletCount": bullet_count, | |
| "hiddenTextFound": bool(hidden_text), | |
| "hiddenTextSample": hidden_text[:300] or None, | |
| }, | |
| } | |
| # ----------------------------------------------------------------- hiding -- | |
| # Below this, nothing is readable on a screen or on paper. A CV does not contain | |
| # text nobody is meant to read unless somebody meant it. | |
| _UNREADABLE_PT = 3.5 | |
| # How close to the page colour counts as invisible. Not exact equality: a CV | |
| # built to hide text often uses 0.98 grey rather than pure white, precisely | |
| # because an exact-match check is the obvious one to write. | |
| _INK_EPSILON = 0.04 | |
| def _is_background_colour(color) -> bool: | |
| """True when a character is drawn in (near) the page's own colour. | |
| pdfplumber reports `non_stroking_color` in whatever colourspace the PDF | |
| used, so this has to handle all of them: | |
| None unknown - treated as visible, never as evidence | |
| 0.97 greyscale, 1 is white | |
| (0.99,1,1) RGB | |
| (0,0,0,0) CMYK, where 0 ink is white | |
| """ | |
| if color is None: | |
| return False | |
| if isinstance(color, (int, float)): | |
| return float(color) >= 1 - _INK_EPSILON | |
| try: | |
| channels = [float(c) for c in color] | |
| except (TypeError, ValueError): | |
| return False | |
| if not channels: | |
| return False | |
| if len(channels) == 4: # CMYK: no ink at all | |
| return all(c <= _INK_EPSILON for c in channels) | |
| return all(c >= 1 - _INK_EPSILON for c in channels) | |
| def _is_hidden_char(char) -> bool: | |
| """A character the page renders but a person cannot read.""" | |
| size = char.get("size") | |
| if isinstance(size, (int, float)) and 0 < float(size) < _UNREADABLE_PT: | |
| return True | |
| return _is_background_colour(char.get("non_stroking_color")) | |
| def _is_hidden_run(run) -> bool: | |
| """A DOCX run Word will render invisibly, or not at all.""" | |
| font = run.font | |
| # w:vanish - Word's own "hidden text" checkbox. | |
| if getattr(font, "hidden", None): | |
| return True | |
| size = getattr(font, "size", None) | |
| if size is not None and getattr(size, "pt", None) and float(size.pt) < _UNREADABLE_PT: | |
| return True | |
| color = getattr(font, "color", None) | |
| rgb = getattr(color, "rgb", None) if color is not None else None | |
| if rgb is None: | |
| return False | |
| try: | |
| r, g, b = int(str(rgb)[0:2], 16), int(str(rgb)[2:4], 16), int(str(rgb)[4:6], 16) | |
| except (ValueError, IndexError): | |
| return False | |
| return r >= 245 and g >= 245 and b >= 245 | |
| def _split_hidden(page): | |
| """Return (visible_text, hidden_text) for one page. | |
| The important subtlety is the RATIO. A CV designed with a dark background | |
| and white type is a legitimate design choice, and on such a page nearly | |
| every character is 'white' - flagging it would accuse a graphic designer of | |
| fraud for owning a portfolio template. Hiding, by contrast, is a small block | |
| of invisible text on an otherwise ordinary page. | |
| So white text is only treated as hidden when it is the MINORITY of the page. | |
| Above half, the page is read as a design and nothing is stripped. | |
| """ | |
| chars = page.chars or [] | |
| if not chars: | |
| return page.extract_text() or "", "" | |
| hidden = [c for c in chars if _is_hidden_char(c)] | |
| if not hidden: | |
| return page.extract_text() or "", "" | |
| if len(hidden) > len(chars) * 0.5: | |
| # A dark-background or light-on-colour design, not a hiding place. | |
| return page.extract_text() or "", "" | |
| hidden_text = "".join(str(c.get("text", "")) for c in hidden).strip() | |
| visible = page.filter( | |
| lambda obj: obj.get("object_type") != "char" or not _is_hidden_char(obj) | |
| ) | |
| return (visible.extract_text() or ""), hidden_text | |
| def _normalize_font_name(font_name: str) -> str: | |
| """Collapse embedded font prefixes and style suffixes into a font family.""" | |
| family = font_name.split("+")[-1].lower() | |
| family = re.sub(r"(bold|italic|oblique|regular|medium|light|semibold|mt)", "", family) | |
| return re.sub(r"[^a-z0-9]", "", family) | |
| def _detect_multiple_columns(page) -> bool: | |
| """Detect repeated, independently populated left/right text regions.""" | |
| words = page.extract_words(use_text_flow=False, keep_blank_chars=False) | |
| if len(words) < 20 or not page.width: | |
| return False | |
| rows: dict[int, list[dict]] = {} | |
| for word in words: | |
| row_key = round(float(word.get("top", 0)) / 5) | |
| rows.setdefault(row_key, []).append(word) | |
| midpoint = float(page.width) / 2 | |
| split_rows = 0 | |
| for row_words in rows.values(): | |
| left = [w for w in row_words if float(w.get("x1", 0)) < midpoint] | |
| right = [w for w in row_words if float(w.get("x0", 0)) > midpoint] | |
| if not left or not right: | |
| continue | |
| left_text = " ".join(str(w.get("text", "")) for w in left) | |
| right_text = " ".join(str(w.get("text", "")) for w in right) | |
| gap = min(float(w.get("x0", 0)) for w in right) - max( | |
| float(w.get("x1", 0)) for w in left | |
| ) | |
| if len(left_text) >= 8 and len(right_text) >= 8 and gap > float(page.width) * 0.08: | |
| split_rows += 1 | |
| return split_rows >= max(4, round(len(rows) * 0.15)) | |
| def _is_sparse_page_text(page_text: str, page) -> bool: | |
| """True when the regular extractor produced much less text than the word layer.""" | |
| words = page.extract_words(use_text_flow=False, keep_blank_chars=False) | |
| if not words: | |
| return False | |
| word_chars = sum(len(str(word.get("text", ""))) for word in words) | |
| return len(page_text.strip()) < max(80, word_chars * 0.35) | |
| def _extract_words_as_lines(page) -> str: | |
| """Rebuild readable lines from positioned words when extract_text is sparse.""" | |
| words = page.extract_words(use_text_flow=False, keep_blank_chars=False) | |
| if not words: | |
| return "" | |
| rows: dict[int, list[dict]] = {} | |
| for word in words: | |
| row_key = round(float(word.get("top", 0)) / 4) | |
| rows.setdefault(row_key, []).append(word) | |
| lines = [] | |
| for _, row_words in sorted(rows.items(), key=lambda item: item[0]): | |
| ordered = sorted(row_words, key=lambda word: float(word.get("x0", 0))) | |
| line = " ".join(str(word.get("text", "")).strip() for word in ordered).strip() | |
| if line: | |
| lines.append(line) | |
| return "\n".join(lines) | |
| def _detect_sections(text: str) -> dict: | |
| """ | |
| Splits the resume text into named sections by detecting section headers. | |
| Returns a dict of section_name → list of content lines. | |
| """ | |
| lines = text.split("\n") | |
| sections: dict[str, list[str]] = {} | |
| current_section: str | None = None | |
| for line in lines: | |
| stripped = line.strip() | |
| if not stripped: | |
| continue | |
| detected = _match_section_header(stripped) | |
| if detected: | |
| current_section = detected | |
| if current_section not in sections: | |
| sections[current_section] = [] | |
| elif current_section: | |
| sections[current_section].append(stripped) | |
| return sections | |
| def _match_section_header(line: str) -> str | None: | |
| """ | |
| Returns the canonical section name if the line looks like a section header, | |
| otherwise returns None. | |
| A line is treated as a header if it's short (≤50 chars) and matches a keyword. | |
| """ | |
| if len(line) > 50: | |
| return None | |
| lower = line.lower().rstrip(":").strip() | |
| for section_name, keywords in SECTION_KEYWORDS.items(): | |
| for kw in keywords: | |
| # Exact match or the line IS the keyword phrase | |
| if re.fullmatch(re.escape(kw), lower): | |
| return section_name | |
| return None | |