# Install Lokalise CLI
npm install -g @lokalise/cli-2

# Download translations
lokalise2 file download \
  --format json \
  --original-filenames=false \
  --project-id YOUR_PROJECT_ID \
  --dest ./locales/

import json
import re
from collections import defaultdict

def check_terminology_consistency(text, glossary_file):
    with open(glossary_file, 'r') as f:
        glossary = json.load(f)

    issues = []

    for term, approved_translation in glossary.items():
        # Find all instances of the source term
        pattern = rf'\b{re.escape(term)}\b'
        matches = re.finditer(pattern, text, re.IGNORECASE)

        for match in matches:
            # Check if context suggests this should use approved translation
            context = text[max(0, match.start()-50):match.end()+50]
            issues.append({
                'term': term,
                'position': match.start(),
                'context': context,
                'approved': approved_translation
            })

    return issues

# Usage
issues = check_terminology_consistency(translated_text, 'medical_glossary.json')
for issue in issues:
    print(f"Check term '{issue['term']}' at position {issue['position']}")

import re
from datetime import datetime

def validate_eu_format_requirements(content, target_locale):
    errors = []

    # Check date formats (EU uses DD/MM/YYYY or DD.MM.YYYY)
    us_date_pattern = r'\d{1,2}/\d{1,2}/\d{4}'
    if target_locale.startswith('en-') and 'US' not in target_locale:
        us_dates = re.findall(us_date_pattern, content)
        if us_dates:
            errors.append(f"US date format detected: {us_dates}")

    # Check measurement units
    imperial_units = ['feet', 'inches', 'fahrenheit', 'pounds']
    for unit in imperial_units:
        if re.search(rf'\b{unit}\b', content, re.IGNORECASE):
            errors.append(f"Imperial unit detected: {unit}")

    # Check currency formats
    dollar_pattern = r'\$\d+'
    if target_locale != 'en-US' and re.search(dollar_pattern, content):
        errors.append("USD currency format in non-US locale")

    return errors

# .github/workflows/localization.yml
name: Update Translations

on:
  push:
    paths:
      - 'docs/**/*.md'
      - 'src/**/*.json'

jobs:
  extract-and-translate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2

      - name: Extract translatable content
        run: |
          # Extract strings from markdown files
          find docs -name '*.md' -exec grep -l 'translatable' {} \; > changed_files.txt

      - name: Send to translation service
        run: |
          # Upload to your translation management system
          curl -X POST "https://api.your-tms.com/projects/upload" \
            -H "Authorization: Bearer ${{ secrets.TMS_TOKEN }}" \
            -F "files=@changed_files.txt"

#!/bin/bash
# generate_localized_assets.sh

LANGUAGES=("de" "fr" "es" "it")
SOURCE_DIR="assets/en"

for lang in "${LANGUAGES[@]}"; do
    TARGET_DIR="assets/${lang}"
    mkdir -p "$TARGET_DIR"

    # Process SVG files with text
    for svg in "$SOURCE_DIR"/*.svg; do
        filename=$(basename "$svg")
        # Replace text using translation file
        python scripts/localize_svg.py "$svg" "translations/${lang}.json" "$TARGET_DIR/$filename"
    done

    # Generate localized PDFs
    pandoc "docs/${lang}/manual.md" \
        --pdf-engine=xelatex \
        --template="templates/eu_compliant.tex" \
        -o "output/manual_${lang}.pdf"
done

import json
import hashlib
from datetime import datetime

class LocalizationAuditLog:
    def __init__(self, log_file='localization_audit.json'):
        self.log_file = log_file
        self.load_log()

    def log_translation_event(self, file_path, source_hash, target_hash, 
                            translator_id, reviewer_id, iso_certified=False):
        event = {
            'timestamp': datetime.utcnow().isoformat(),
            'file_path': file_path,
            'source_hash': source_hash,
            'target_hash': target_hash,
            'translator_id': translator_id,
            'reviewer_id': reviewer_id,
            'iso_17100_certified': iso_certified,
            'regulatory_category': self.get_regulatory_category(file_path)
        }

        self.audit_log.append(event)
        self.save_log()

    def get_regulatory_category(self, file_path):
        if 'ifu' in file_path.lower():
            return 'instructions_for_use'
        elif 'sds' in file_path.lower():
            return 'safety_data_sheet'
        elif 'declaration' in file_path.lower():
            return 'conformity_declaration'
        return 'general_documentation'

# Parallel translation processing
find docs -name '*.md' | parallel -j4 python translate_file.py {}

# Simple monitoring script
import requests
import smtplib
from email.mime.text import MIMEText

def check_translation_freshness():
    stale_files = []

    for file_path in get_documentation_files():
        source_modified = get_last_modified(file_path)
        translation_modified = get_translation_last_modified(file_path)

        if source_modified > translation_modified:
            stale_files.append(file_path)

    if stale_files:
        send_alert(f"Stale translations detected: {stale_files}")

    return stale_files