python-po-lint 0.1.0__py3-none-any.whl

po_lint/detector.py

@@ -0,0 +1,314 @@
+"""Language detection using fastText for .po file linting."""
+
+import os
+import re
+import urllib.request
+from pathlib import Path
+
+import fasttext
+
+# Suppress fastText warnings about "\n" in input
+fasttext.FastText.eprint = lambda x: None
+
+# Default minimum cleaned text length to attempt language detection.
+# Short strings are unreliable — loan words, cognates, and brand names
+# make detection impossible for anything under ~30 characters.
+DEFAULT_MIN_DETECTION_LENGTH = 30
+
+FULL_MODEL_URL = "https://dl.fbaipublicfiles.com/fasttext/supervised-models/lid.176.bin"
+COMPACT_MODEL_URL = "https://dl.fbaipublicfiles.com/fasttext/supervised-models/lid.176.ftz"
+MODEL_DIR = Path(os.environ.get("PO_LINT_MODEL_DIR", Path.home() / ".cache" / "po-lint"))
+
+# Common aliases: locale directory names that don't match the ISO 639-1 code
+# used by fastText. Only edge cases go here — most codes work as-is.
+LOCALE_ALIASES = {
+    "zh_Hans": "zh",
+    "zh_Hant": "zh",
+    "zh_CN": "zh",
+    "zh_TW": "zh",
+    "nb": "no",       # Norwegian Bokmål → fastText uses "no"
+    "nn": "no",       # Norwegian Nynorsk → fastText uses "no"
+    "pt_BR": "pt",
+    "pt_PT": "pt",
+    "es_AR": "es",
+    "es_MX": "es",
+    "en_US": "en",
+    "en_GB": "en",
+    "fr_CA": "fr",
+    "fr_FR": "fr",
+    "sr_Latn": "sr",
+    "sr_Cyrl": "sr",
+}
+
+# Carrier phrases per language — used for second-pass confirmation.
+# When fastText flags a wrong language, we re-test with a carrier phrase
+# prepended. If the originally detected language drops significantly (>60%)
+# and the expected language rises significantly (>20%), the original detection
+# was likely a false positive on ambiguous text.
+# Uses short "context" style phrases ("In X one says") to give just enough
+# signal without overpowering real contamination in related languages.
+CARRIER_PHRASES = {
+    "af": "In Afrikaans sê mens",
+    "ar": "بالعربية يقال",
+    "bg": "На български се казва",
+    "bn": "বাংলায় বলা হয়",
+    "bs": "Na bosanskom se kaže",
+    "ca": "En català es diu",
+    "cs": "Česky se říká",
+    "da": "På dansk siger man",
+    "de": "Auf Deutsch sagt man",
+    "el": "Στα ελληνικά λέμε",
+    "en": "In English one says",
+    "es": "En español se dice",
+    "et": "Eesti keeles öeldakse",
+    "fa": "به فارسی می‌گویند",
+    "fi": "Suomeksi sanotaan",
+    "fr": "En français on dit",
+    "he": "בעברית אומרים",
+    "hi": "हिंदी में कहते हैं",
+    "hr": "Na hrvatskom se kaže",
+    "hu": "Magyarul azt mondják",
+    "id": "Dalam bahasa Indonesia dikatakan",
+    "it": "In italiano si dice",
+    "ja": "日本語では",
+    "ko": "한국어로는",
+    "lt": "Lietuviškai sakoma",
+    "lv": "Latviski saka",
+    "mk": "На македонски се вели",
+    "ms": "Dalam bahasa Melayu dikatakan",
+    "nl": "In het Nederlands zegt men",
+    "no": "På norsk sier man",
+    "pl": "Po polsku mówi się",
+    "pt": "Em português diz-se",
+    "ro": "În română se spune",
+    "ru": "По-русски говорят",
+    "sk": "Po slovensky sa hovorí",
+    "sl": "V slovenščini se reče",
+    "sr": "На српском се каже",
+    "sv": "På svenska säger man",
+    "sw": "Kwa Kiswahili tunasema",
+    "th": "ในภาษาไทยพูดว่า",
+    "tr": "Türkçede denir ki",
+    "uk": "Українською кажуть",
+    "vi": "Trong tiếng Việt người ta nói",
+    "zh": "用中文来说",
+}
+
+# Confused language merges: when fastText detects a language that is commonly
+# confused with the expected language, merge its score into the expected language's
+# score. This is directional — e.g. Swedish text can be confused as German (sv merges
+# de), but German text is rarely confused as Swedish (de does NOT merge sv).
+# This replaces blanket skipping with score redistribution, so genuinely wrong
+# translations at very high confidence are still caught.
+CONFUSED_MERGES: dict[str, set[str]] = {
+    # Scandinavian languages — very similar vocabulary and grammar
+    "no": {"da", "sv", "nb", "nn", "de"},
+    "da": {"no", "sv", "nb", "nn", "de"},
+    "sv": {"no", "da", "nb", "nn", "de"},
+    "nb": {"no", "da", "sv", "nn", "de"},
+    "nn": {"no", "da", "sv", "nb", "de"},
+    # Romance languages
+    "pt": {"es", "gl"},
+    "es": {"pt", "gl"},
+    "gl": {"pt", "es"},
+    # Germanic
+    "nl": {"af"},
+    "af": {"nl"},
+    # Turkic languages
+    "tr": {"az"},
+    "az": {"tr"},
+    # Cyrillic languages — shared script and vocabulary
+    "uk": {"ru"},
+    "ru": {"uk"},
+    "bg": {"mk"},
+    "mk": {"bg"},
+    # Indic languages — shared Devanagari script
+    "hi": {"mr"},
+    "mr": {"hi"},
+    # Arabic script languages — shared script and vocabulary roots
+    "ar": {"fa", "ur"},
+    "fa": {"ar", "ur"},
+    "ur": {"ar", "fa"},
+}
+
+
+def _normalize_locale(locale: str) -> str:
+    """Normalize a locale directory name to a fastText-compatible ISO code."""
+    return LOCALE_ALIASES.get(locale, locale)
+
+
+def _use_compact_model() -> bool:
+    """Check if compact model is requested via environment variable."""
+    return os.environ.get("PO_LINT_COMPACT_MODEL", "").lower() in ("1", "true", "yes")
+
+
+def ensure_model(compact: bool = False) -> Path:
+    """Download the fastText language ID model if not already cached."""
+    if compact or _use_compact_model():
+        url = COMPACT_MODEL_URL
+        path = MODEL_DIR / "lid.176.ftz"
+    else:
+        url = FULL_MODEL_URL
+        path = MODEL_DIR / "lid.176.bin"
+
+    if path.exists():
+        return path
+    MODEL_DIR.mkdir(parents=True, exist_ok=True)
+    model_type = "compact" if "ftz" in path.name else "full"
+    print(f"Downloading fastText language model ({model_type}) to {path}...")
+    urllib.request.urlretrieve(url, path)
+    return path
+
+
+_ft_model = None
+
+
+def init_model(compact: bool = False) -> None:
+    """Initialize the fastText model. Call before linting to select model variant."""
+    global _ft_model
+    model_path = ensure_model(compact)
+    _ft_model = fasttext.load_model(str(model_path))
+
+
+def get_ft_model() -> fasttext.FastText._FastText:
+    """Load the fastText model (singleton). Auto-initializes with default if not yet loaded."""
+    global _ft_model
+    if _ft_model is None:
+        init_model()
+    return _ft_model
+
+
+def clean_text(text: str) -> str:
+    """Strip HTML tags, template tags, format strings, and URLs for better detection."""
+    text = re.sub(r"<[^>]+>", " ", text)
+    text = re.sub(r"\{[%{].*?[%}]\}", " ", text)
+    text = re.sub(r"%\([^)]+\)[sd]", " ", text)
+    text = re.sub(r"https?://\S+", " ", text)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+
+def detect_language(text: str, min_detection_length: int = DEFAULT_MIN_DETECTION_LENGTH) -> tuple[str, float]:
+    """Detect language of text using fastText.
+
+    Returns (lang_code, confidence). Returns ("unknown", 0.0) for text
+    shorter than min_detection_length after cleaning.
+    """
+    cleaned = clean_text(text)
+    if len(cleaned) < min_detection_length:
+        return ("unknown", 0.0)
+
+    return _detect_fasttext(cleaned)
+
+
+def _detect_fasttext(text: str, k: int = 1) -> tuple[str, float] | dict[str, float]:
+    """Detect language using fastText.
+
+    With k=1, returns (lang, confidence).
+    With k>1, returns a dict of {lang: confidence} for the top-k predictions.
+    """
+    model = get_ft_model()
+    predictions = model.predict(text.replace("\n", " "), k=k)
+    if k == 1:
+        label = predictions[0][0].replace("__label__", "")
+        confidence = predictions[1][0]
+        return (label, confidence)
+    return {
+        label.replace("__label__", ""): conf
+        for label, conf in zip(predictions[0], predictions[1])
+    }
+
+
+def _merge_confused_scores(
+    scores: dict[str, float], expected_code: str,
+) -> dict[str, float]:
+    """Merge scores from languages commonly confused with the expected language.
+
+    When fastText splits its confidence between the expected language and
+    languages it commonly confuses with it, this merges those scores together.
+    For example, Swedish text might get de:63% + sv:12% — if sv has de in its
+    merge set, the adjusted score becomes sv:75%.
+    """
+    merge_from = CONFUSED_MERGES.get(expected_code)
+    if not merge_from:
+        return scores
+    adjusted = dict(scores)
+    bonus = sum(scores.get(lang, 0.0) for lang in merge_from)
+    adjusted[expected_code] = adjusted.get(expected_code, 0.0) + bonus
+    for lang in merge_from:
+        adjusted.pop(lang, None)
+    return adjusted
+
+
+def is_wrong_language(
+    msgstr: str,
+    expected_lang: str,
+    confidence_threshold: float = 0.5,
+    source_language: str = "en",
+    msgid: str = "",
+    min_detection_length: int = DEFAULT_MIN_DETECTION_LENGTH,
+) -> tuple[bool, str, float]:
+    """Check if a translation is in the wrong language.
+
+    Only checks strings >= min_detection_length characters after cleaning.
+    Shorter strings are too ambiguous for reliable detection.
+
+    Args:
+        msgstr: The translated text to check.
+        expected_lang: The locale code this translation should be in.
+        confidence_threshold: Minimum confidence to flag a wrong language.
+        source_language: The source language of the .po file (default: "en").
+            Detections matching the source language are allowed, since borrowed
+            words from the source language are common in translations.
+        msgid: The source text (currently unused, reserved for future use).
+        min_detection_length: Minimum cleaned text length to attempt detection.
+
+    Returns (is_wrong, detected_lang, confidence).
+    """
+    cleaned = clean_text(msgstr)
+    if len(cleaned) < min_detection_length:
+        return (False, "unknown", 0.0)
+
+    expected_code = _normalize_locale(expected_lang)
+
+    # Get top-5 scores and merge confused language scores
+    scores = _detect_fasttext(cleaned, k=5)
+    adjusted = _merge_confused_scores(scores, expected_code)
+    detected_lang = max(adjusted, key=adjusted.get)
+    confidence = scores.get(detected_lang, adjusted[detected_lang])
+
+    if detected_lang == "unknown":
+        return (False, detected_lang, confidence)
+
+    if detected_lang == expected_code:
+        return (False, detected_lang, adjusted[detected_lang])
+
+    # Allow source language — borrowed words are common
+    source_code = _normalize_locale(source_language)
+    if detected_lang == source_code:
+        return (False, detected_lang, confidence)
+
+    # Below confidence threshold — not certain enough to flag
+    if confidence < confidence_threshold:
+        return (False, detected_lang, confidence)
+
+    # Second-pass confirmation with carrier phrase.
+    # Re-test with a short phrase in the expected language prepended.
+    # Compare how the detected language's confidence changes:
+    # - Real contamination holds strong (detected lang barely drops)
+    # - False positives crumble (detected lang drops >60%, expected rises >20%)
+    carrier = CARRIER_PHRASES.get(expected_code)
+    if carrier:
+        bare_det_conf = scores.get(detected_lang, 0.0)
+        bare_exp_conf = scores.get(expected_code, 0.0)
+        boosted_scores = _detect_fasttext(f"{carrier} {cleaned}", k=5)
+        boosted_det_conf = boosted_scores.get(detected_lang, 0.0)
+        boosted_exp_conf = boosted_scores.get(expected_code, 0.0)
+
+        if bare_det_conf > 0:
+            det_drop = (bare_det_conf - boosted_det_conf) / bare_det_conf
+            exp_rise = boosted_exp_conf - bare_exp_conf
+            if det_drop > 0.60 and exp_rise > 0.20:
+                return (False, detected_lang, confidence)
+
+    return (True, detected_lang, confidence)

po_lint/linter.py

@@ -0,0 +1,277 @@
+"""Main linter that ties all checks together and walks locale directories."""
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+import polib
+
+from po_lint.checks import (
+    Issue,
+    IssueType,
+    Severity,
+    check_garbled_text,
+    check_shifted_entry,
+    check_wrong_script,
+)
+from po_lint.detector import DEFAULT_MIN_DETECTION_LENGTH, is_wrong_language
+
+IGNORE_FILE = ".po-lint-ignore"
+
+
+@dataclass
+class IgnoreRule:
+    """A single ignore rule from .po-lint-ignore."""
+
+    msgid: str
+    msgctxt: str  # Empty string means match any context
+    languages: set[str]  # Empty set means match all languages
+
+
+def load_ignore_rules(locale_dir: Path) -> list[IgnoreRule]:
+    """Load ignore rules from a .po-lint-ignore file in the locale directory.
+
+    Format:
+      # Comment
+      Some msgid                              → ignore for all languages, any context
+      [ar,hi] Some msgid                      → ignore only for Arabic and Hindi
+      screening status::Some msgid            → ignore with specific msgctxt
+      [ar] screening status::Some msgid       → both language scope and context
+    """
+    ignore_file = locale_dir / IGNORE_FILE
+    if not ignore_file.exists():
+        return []
+
+    rules = []
+    for line in ignore_file.read_text().splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+
+        languages: set[str] = set()
+        # Parse optional language scope: [ar,hi,zh_Hans]
+        if line.startswith("["):
+            bracket_end = line.index("]")
+            lang_str = line[1:bracket_end]
+            languages = {lang.strip() for lang in lang_str.split(",")}
+            line = line[bracket_end + 1:].strip()
+
+        # Parse optional context: msgctxt::msgid
+        if "::" in line:
+            msgctxt, msgid = line.split("::", 1)
+        else:
+            msgctxt = ""
+            msgid = line
+
+        rules.append(IgnoreRule(msgid=msgid, msgctxt=msgctxt, languages=languages))
+
+    return rules
+
+
+def _is_ignored(msgid: str, msgctxt: str | None, locale: str, ignore_rules: list[IgnoreRule]) -> bool:
+    """Check if an entry matches any ignore rule."""
+    for rule in ignore_rules:
+        # Check language scope
+        if rule.languages and locale not in rule.languages:
+            continue
+        # Check msgid
+        if rule.msgid != msgid:
+            continue
+        # Check context
+        if rule.msgctxt and rule.msgctxt != (msgctxt or ""):
+            continue
+        return True
+    return False
+
+
+def extract_locale_from_path(po_file: Path) -> str | None:
+    """Extract the locale code from a .po file path.
+
+    Expects paths like: .../locale/<lang>/LC_MESSAGES/django.po
+    """
+    parts = po_file.parts
+    for i, part in enumerate(parts):
+        if part == "LC_MESSAGES" and i >= 1:
+            return parts[i - 1]
+        if part == "locale" and i + 1 < len(parts):
+            return parts[i + 1]
+    return None
+
+
+def _find_locale_root(po_file: Path) -> Path | None:
+    """Find the locale/ directory that contains this .po file."""
+    for parent in po_file.parents:
+        if parent.name == "locale":
+            return parent
+    return None
+
+
+def lint_po_file(
+    po_file: Path,
+    locale: str | None = None,
+    source_language: str = "en",
+    confidence_threshold: float = 0.5,
+    min_text_length: int = 3,
+    min_detection_length: int = DEFAULT_MIN_DETECTION_LENGTH,
+    ignore_patterns: list[str] | None = None,
+    ignore_rules: list[IgnoreRule] | None = None,
+) -> list[Issue]:
+    """Lint a single .po file and return all issues found."""
+    if locale is None:
+        locale = extract_locale_from_path(po_file)
+    if locale is None:
+        return []
+
+    compiled_ignores = [re.compile(p) for p in (ignore_patterns or [])]
+    ignore_rules = ignore_rules or []
+
+    try:
+        catalog = polib.pofile(str(po_file))
+    except (OSError, SyntaxError) as e:
+        return [
+            Issue(
+                file=str(po_file),
+                line=0,
+                msgid="",
+                msgstr="",
+                issue_type=IssueType.GARBLED_TEXT,
+                severity=Severity.ERROR,
+                message=f"Failed to parse .po file: {e}",
+            )
+        ]
+
+    issues = []
+
+    for entry in catalog.translated_entries():
+        msgid = entry.msgid
+        msgstr = entry.msgstr
+
+        if not msgstr or len(msgstr.strip()) < min_text_length:
+            continue
+
+        # Skip entries in the ignore file
+        if _is_ignored(msgid, entry.msgctxt, locale, ignore_rules):
+            continue
+
+        # Skip entries matching ignore patterns
+        if any(p.search(msgid) or p.search(msgstr) for p in compiled_ignores):
+            continue
+
+        # Skip entries that are mostly format strings / placeholders / URLs
+        if _is_non_linguistic(msgstr):
+            continue
+
+        # Skip entries where the translation is identical to the source
+        # (intentionally untranslated — common for brand names, acronyms, technical terms)
+        if msgid == msgstr:
+            continue
+
+        # 1. Wrong script check (fast, no model needed)
+        issue = check_wrong_script(msgstr, locale)
+        if issue:
+            issue.file = str(po_file)
+            issue.line = entry.linenum
+            issue.msgid = msgid
+            issues.append(issue)
+            continue  # If wrong script, skip language detection (it would also flag)
+
+        # 2. Garbled text check
+        issue = check_garbled_text(msgstr)
+        if issue:
+            issue.file = str(po_file)
+            issue.line = entry.linenum
+            issue.msgid = msgid
+            issues.append(issue)
+            continue
+
+        # 3. Shifted entry check
+        issue = check_shifted_entry(msgid, msgstr)
+        if issue:
+            issue.file = str(po_file)
+            issue.line = entry.linenum
+            issues.append(issue)
+
+        # 4. Wrong language check (uses fastText)
+        is_wrong, detected_lang, confidence = is_wrong_language(
+            msgstr, locale, confidence_threshold, source_language, msgid=msgid,
+            min_detection_length=min_detection_length,
+        )
+        if is_wrong:
+            issues.append(
+                Issue(
+                    file=str(po_file),
+                    line=entry.linenum,
+                    msgid=msgid,
+                    msgstr=msgstr,
+                    issue_type=IssueType.WRONG_LANGUAGE,
+                    severity=Severity.ERROR,
+                    message=f"Expected {locale}, detected {detected_lang} (confidence: {confidence:.0%})",
+                    detected_lang=detected_lang,
+                    confidence=confidence,
+                )
+            )
+
+    return issues
+
+
+def _is_non_linguistic(text: str) -> bool:
+    """Check if text is mostly non-linguistic (URLs, format strings, numbers, etc.)."""
+    cleaned = text
+    # Strip Django/Python format strings
+    cleaned = re.sub(r"%\([^)]+\)[sd]", "", cleaned)
+    cleaned = re.sub(r"%[sd]", "", cleaned)
+    cleaned = re.sub(r"\{[^}]*\}", "", cleaned)
+    # Strip HTML tags
+    cleaned = re.sub(r"<[^>]+>", "", cleaned)
+    # Strip URLs
+    cleaned = re.sub(r"https?://\S+", "", cleaned)
+    # Strip numbers and punctuation
+    cleaned = re.sub(r"[0-9.,;:!?/\\@#$%^&*()_+=\[\]{}<>\"'\-\s]", "", cleaned)
+    # If very little text remains, it's non-linguistic
+    return len(cleaned) < 3
+
+
+def lint_locale_dir(
+    locale_dir: Path,
+    languages: list[str] | None = None,
+    source_language: str = "en",
+    confidence_threshold: float = 0.5,
+    min_text_length: int = 3,
+    min_detection_length: int = DEFAULT_MIN_DETECTION_LENGTH,
+    ignore_patterns: list[str] | None = None,
+) -> list[Issue]:
+    """Lint all .po files in a locale directory.
+
+    Loads .po-lint-ignore from the locale directory if present.
+
+    Args:
+        locale_dir: Path to a locale/ directory containing <lang>/LC_MESSAGES/*.po
+        languages: If set, only lint these language codes. If empty, lint all.
+        source_language: The source language of the .po files (default: "en").
+        confidence_threshold: Minimum confidence to flag a wrong language.
+        min_text_length: Minimum msgstr length to check.
+        ignore_patterns: Regex patterns for msgid/msgstr to skip.
+    """
+    ignore_rules = load_ignore_rules(locale_dir)
+    issues = []
+
+    for po_file in sorted(locale_dir.rglob("*.po")):
+        locale = extract_locale_from_path(po_file)
+        if locale is None:
+            continue
+        if languages and locale not in languages:
+            continue
+
+        file_issues = lint_po_file(
+            po_file,
+            locale=locale,
+            source_language=source_language,
+            confidence_threshold=confidence_threshold,
+            min_text_length=min_text_length,
+            min_detection_length=min_detection_length,
+            ignore_patterns=ignore_patterns,
+            ignore_rules=ignore_rules,
+        )
+        issues.extend(file_issues)
+
+    return issues

python_po_lint-0.1.0.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: python-po-lint
+Version: 0.1.0
+Summary: Lint .po translation files for contamination, wrong languages, shifts, and garbled text
+Author: PesCheck
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: fasttext-wheel>=0.9.2
+Requires-Dist: numpy<2
+Requires-Dist: polib>=1.2
+Description-Content-Type: text/markdown
+
+# python-po-lint
+
+Lint `.po` translation files for contamination, wrong languages, shifts, and garbled text.
+
+## Features
+
+- **Wrong script detection** — catches Cyrillic in a Dutch file, Arabic in French, etc.
+- **Wrong language detection** — hybrid fastText + lingua approach (fastText for long strings, lingua for short ones)
+- **Shifted entry detection** — finds translations that got shifted to the wrong msgid
+- **Garbled text detection** — catches corrupted/broken unicode
+
+## Installation
+
+```bash
+pip install python-po-lint
+```
+
+## Usage
+
+```bash
+# Lint a locale directory
+po-lint locale/
+
+# Lint with config from pyproject.toml
+po-lint
+
+# Only check specific languages
+po-lint locale/ --languages fr de nl
+```
+
+## Configuration
+
+Add to your `pyproject.toml`:
+
+```toml
+[tool.po-lint]
+# Explicit locale directories (relative to project root)
+paths = ["locale"]
+
+# Auto-discover locale dirs from installed Python packages
+packages = ["myapp", "myotherapp"]
+
+# Only check these languages (empty = all)
+languages = []
+
+# Minimum confidence to flag wrong language (0.0 - 1.0)
+confidence_threshold = 0.5
+
+# Skip entries with msgstr shorter than this
+min_text_length = 3
+
+# Regex patterns to ignore (matched against msgid and msgstr)
+ignore_patterns = []
+```

python_po_lint-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+po_lint/__init__.py,sha256=2VjrIp2SLGcJKCEhgQ_Ss706P6o6RD86B9-wSPKJ-94,134
+po_lint/checks.py,sha256=cpySTm9QJzcy31rjOKgBsNeXeeHFmzfdCHjhUa2nHLQ,10556
+po_lint/cli.py,sha256=3bc5_ZaZ4-WK29JsyqwgI677p4F6WxpaAnR0_-_9g2Y,6866
+po_lint/config.py,sha256=Ya3Q78_LZ6x4RrmWpexH4qFrHgKBxyUlX103XOXSQSI,3053
+po_lint/detector.py,sha256=fA1tDP3Lf05bFLh-ybvpAgHTAJPC7cut8dpZc7REssg,11735
+po_lint/linter.py,sha256=inT8gSP75nosm9S_uCEKURo4MICVUHqdIFmElQhLAgg,9038
+python_po_lint-0.1.0.dist-info/METADATA,sha256=0cw6AlhCs3UBVJRrkV3YYgAfz79NvmDnoOCctxMezyk,1638
+python_po_lint-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_po_lint-0.1.0.dist-info/entry_points.txt,sha256=W9_2iuo5yQtYgY5U8qVH7h6Xq8XSj0KsF71TR_9_xDE,45
+python_po_lint-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+python_po_lint-0.1.0.dist-info/RECORD,,

python_po_lint-0.1.0.dist-info/WHEEL

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

python_po_lint-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+po-lint = po_lint.cli:main