pip install PolyglotX

git clone https://github.com/6x-u/polyglotx.git
cd polyglotx
pip install -e .

from PolyglotX import arbe

# This will automatically catch and translate errors to Arabic
x = undefined_variable

# Output:
# خطأ في الاسم: name 'undefined_variable' is not defined
# MERO tele QP4RM

from PolyglotX import tr

result = 10 / 0

# Output:
# Sıfıra Bölme Hatası: division by zero
# MERO tele QP4RM

from PolyglotX import ja

my_list = [1, 2, 3]
value = my_list[10]

# Output:
# インデックスエラー: list index out of range
# MERO tele QP4RM

from PolyglotX import (
    arbe,  # Arabic - العربية
    tr,    # Turkish - Türkçe
    ja,    # Japanese - 日本語
    zh,    # Chinese - 中文
    ku,    # Kurdish - کوردی
    es,    # Spanish - Español
    hi,    # Hindi - हिन्दी
    fr,    # French - Français
    ru,    # Russian - Русский
    de,    # German - Deutsch
    pt     # Portuguese - Português
)

class ExceptionHandler(language: str = 'ar', 
                       show_credits: bool = True, 
                       auto_exit: bool = True)

from PolyglotX.core.exception_handler import ExceptionHandler

# Create handler instance
handler = ExceptionHandler(
    language='ar',        # Arabic translation
    show_credits=True,    # Show credits
    auto_exit=False       # Don't exit after error
)

# Activate the handler
handler.install()

# Your code here - errors will be translated
try:
    x = undefined_variable
except:
    pass

# Get error statistics
stats = handler.get_error_stats()
print(f"Total errors: {stats['total_errors']}")

# Deactivate when done
handler.uninstall()

from PolyglotX.core.exception_handler import GlobalExceptionHandler

# First instance
handler1 = GlobalExceptionHandler(language='ar')

# Second call returns the same instance
handler2 = GlobalExceptionHandler(language='tr')

# handler1 and handler2 are the same object
print(handler1 is handler2)  # True

from PolyglotX.core.exception_handler import ErrorTranslator

translator = ErrorTranslator(language='ar')

try:
    result = 10 / 0
except Exception as e:
    translated = translator.translate_error(e)
    print(translated)
    # خطأ في القسمة على صفر: division by zero

from PolyglotX.core.exception_handler import TracebackTranslator
import sys

translator = TracebackTranslator(language='ar')

try:
    undefined_variable
except:
    exc_info = sys.exc_info()
    formatted = translator.format_traceback(exc_info)
    print(formatted)

from PolyglotX.core.exception_handler import ContextualErrorHandler

handler = ContextualErrorHandler(
    language='ar',
    include_locals=True,    # Show local variables
    include_globals=False   # Don't show globals
)
handler.install()

from PolyglotX.core.exception_handler import AsyncExceptionHandler
import asyncio

handler = AsyncExceptionHandler(language='ar')

async def my_async_function():
    await handler.handle_async_exception(
        some_async_operation()
    )

asyncio.run(my_async_function())

from PolyglotX.core.exception_handler import ThreadSafeExceptionHandler
import threading

handler = ThreadSafeExceptionHandler(language='ar')
handler.install()

def worker():
    # Errors in threads will be handled safely
    x = undefined_variable

threads = [threading.Thread(target=worker) for _ in range(10)]
for t in threads:
    t.start()
for t in threads:
    t.join()

from PolyglotX.core.exception_handler import ChainedExceptionHandler

handler = ChainedExceptionHandler(language='ar')
handler.add_handler(custom_handler_1)
handler.add_handler(custom_handler_2)
handler.install()

from PolyglotX.core.exception_handler import FilteredExceptionHandler

handler = FilteredExceptionHandler(
    language='ar',
    exception_types=[ValueError, TypeError]  # Only handle these
)
handler.install()

from PolyglotX.core.exception_handler import LoggingExceptionHandler
import logging

logging.basicConfig(level=logging.ERROR)

handler = LoggingExceptionHandler(
    language='ar',
    logger_name='my_app'
)
handler.install()

from PolyglotX.core.translator import Translator

translator = Translator(
    target_language='ar',      # Target language
    source_language='auto'     # Auto-detect source
)

# Translate text
result = translator.translate("Error: File not found")
print(result)  # خطأ: الملف غير موجود

# Translate with parts preservation
result = translator.translate_parts("File 'config.json' not found")
print(result)  # Preserves 'config.json' while translating rest

from PolyglotX.core.translator import MultiEngineTranslator

translator = MultiEngineTranslator(
    target_language='ar',
    engines=['google', 'mymemory', 'libre']  # Priority order
)

result = translator.translate("ValueError")

from PolyglotX.core.translator import CachedTranslator

translator = CachedTranslator(
    target_language='ar',
    cache_file='translation_cache.json',
    max_cache_size=10000
)

# First call: translates and caches
result1 = translator.translate("Error")

# Second call: retrieved from cache (instant)
result2 = translator.translate("Error")

# Get cache statistics
stats = translator.get_cache_stats()
print(f"Cache hit rate: {stats['hit_rate']}")

from PolyglotX.core.translator import BatchTranslator

translator = BatchTranslator(
    target_language='ar',
    batch_size=100,
    parallel=True
)

errors = [
    "TypeError: invalid type",
    "ValueError: invalid value",
    "NameError: name not defined",
    # ... hundreds more
]

# Translate all at once
translated = translator.translate_batch(errors)

# Auto-batch with optimization
translated = translator.auto_translate_batch(errors)

from PolyglotX.core.translator import OfflineTranslator

translator = OfflineTranslator(
    target_language='ar',
    dictionary_file='ar_dict.json'
)

# Works without internet
result = translator.translate("Error")

from PolyglotX.core.translator import SmartTranslator

translator = SmartTranslator(
    target_language='ar',
    quality_threshold=0.8,     # Minimum quality score
    enable_ai=True             # Use AI enhancement
)

result = translator.translate("Complex error message")

# Get translation quality score
quality = translator.get_quality_score(result)

from PolyglotX.handlers.error_formatter import ColoredErrorFormatter

formatter = ColoredErrorFormatter(
    language='ar',
    color_scheme='dark'  # 'dark' or 'light'
)

try:
    x = 10 / 0
except Exception as e:
    formatted = formatter.format(e)
    print(formatted)  # Colored output

from PolyglotX.handlers.error_formatter import HTMLErrorFormatter

formatter = HTMLErrorFormatter(
    language='ar',
    style='bootstrap'  # 'bootstrap', 'tailwind', or 'custom'
)

try:
    x = undefined_variable
except Exception as e:
    html = formatter.format(e)
    # Returns complete HTML with styling

from PolyglotX.handlers.error_formatter import JSONErrorFormatter
import json

formatter = JSONErrorFormatter(
    language='ar',
    pretty=True  # Pretty print JSON
)

try:
    result = 10 / 0
except Exception as e:
    json_output = formatter.format(e)
    error_dict = json.loads(json_output)
    print(error_dict['error_type'])
    print(error_dict['error_message'])
    print(error_dict['traceback'])

from PolyglotX.handlers.error_formatter import XMLErrorFormatter

formatter = XMLErrorFormatter(language='ar')

try:
    my_list[100]
except Exception as e:
    xml = formatter.format(e)
    # Returns XML structure

from PolyglotX.handlers.error_formatter import MarkdownErrorFormatter

formatter = MarkdownErrorFormatter(language='ar')

try:
    import nonexistent_module
except Exception as e:
    markdown = formatter.format(e)
    # Perfect for documentation

from PolyglotX.handlers.output_handler import ConsoleOutputHandler

handler = ConsoleOutputHandler(
    language='ar',
    colored=True
)

handler.handle(exception_object)

from PolyglotX.handlers.output_handler import FileOutputHandler

handler = FileOutputHandler(
    language='ar',
    file_path='errors.log',
    mode='a',  # Append mode
    encoding='utf-8'
)

handler.handle(exception_object)

from PolyglotX.handlers.output_handler import EmailOutputHandler

handler = EmailOutputHandler(
    language='ar',
    smtp_server='smtp.gmail.com',
    smtp_port=587,
    sender='errors@myapp.com',
    recipients=['admin@myapp.com'],
    username='your_email',
    password='your_password'
)

handler.handle(exception_object)

from PolyglotX.handlers.output_handler import WebhookOutputHandler

handler = WebhookOutputHandler(
    language='ar',
    webhook_url='https://hooks.slack.com/services/...',
    method='POST',
    headers={'Content-Type': 'application/json'}
)

handler.handle(exception_object)

from PolyglotX.handlers.output_handler import DatabaseOutputHandler

handler = DatabaseOutputHandler(
    language='ar',
    connection_string='postgresql://user:pass@localhost/db',
    table_name='errors'
)

handler.handle(exception_object)

from PolyglotX.utils.decorators import handle_exceptions

@handle_exceptions(language='ar', show_credits=True)
def my_function():
    x = undefined_variable
    return x

# Errors are automatically caught and translated
my_function()

from PolyglotX.utils.decorators import translate_errors

@translate_errors(language='ar')
def divide(a, b):
    return a / b

result = divide(10, 0)  # Error translated to Arabic

from PolyglotX.utils.decorators import retry_on_error

@retry_on_error(max_retries=3, delay=1.0, language='ar')
def unreliable_operation():
    # May fail, will retry up to 3 times
    import random
    if random.random() < 0.5:
        raise ValueError("Random failure")
    return "Success"

result = unreliable_operation()

from PolyglotX.utils.decorators import fallback_on_error

@fallback_on_error(fallback_value=None, language='ar')
def risky_operation():
    x = undefined_variable
    return x

result = risky_operation()  # Returns None instead of crashing

from PolyglotX.utils.decorators import log_exceptions
import logging

logging.basicConfig(level=logging.ERROR)

@log_exceptions(language='ar', logger_name='my_app')
def my_function():
    x = 10 / 0

my_function()  # Error logged in Arabic

from PolyglotX.utils.decorators import measure_exception_time

@measure_exception_time(language='ar')
def slow_operation():
    import time
    time.sleep(2)
    raise ValueError("Error after 2 seconds")

slow_operation()  # Shows error + execution time

from PolyglotX.utils.decorators import suppress_exceptions

@suppress_exceptions(exception_types=[ValueError])
def my_function():
    raise ValueError("This will be suppressed")

my_function()  # No error raised

from PolyglotX.utils.decorators import notify_on_exception

@notify_on_exception(
    language='ar',
    email='admin@example.com',
    webhook='https://hooks.slack.com/...'
)
def critical_operation():
    # If error occurs, send notifications
    raise RuntimeError("Critical error")

critical_operation()

from PolyglotX.utils.helpers import (
    detect_language,
    extract_error_info,
    format_stack_trace,
    parse_exception,
    sanitize_error_message,
    get_error_context,
    calculate_error_hash,
    group_similar_errors,
    suggest_fixes,
    find_error_documentation
)

# Detect language of text
lang = detect_language("مرحبا")  # Returns 'ar'

# Extract error information
error_info = extract_error_info(exception_object)

# Format stack trace
formatted = format_stack_trace(traceback_object)

# Parse exception details
details = parse_exception(exception_object)

# Sanitize error message
clean_msg = sanitize_error_message("Error with sensitive data: API_KEY_123")

# Get error context
context = get_error_context(exception_object, lines_before=5, lines_after=5)

# Calculate unique hash for error
error_hash = calculate_error_hash(exception_object)

# Group similar errors
groups = group_similar_errors([error1, error2, error3])

# Get fix suggestions
suggestions = suggest_fixes(exception_object)

# Find documentation for error
docs = find_error_documentation("ValueError")

# Translate single text
polyglotx translate "Error occurred" --language ar

# Translate from file
polyglotx translate --file errors.txt --language ar --output translated.txt

# Interactive mode
polyglotx translate --interactive --language ar

# Test translation engine
polyglotx test --language ar

# Test specific errors
polyglotx test --errors ValueError TypeError --language ar

# Test all languages
polyglotx test --all-languages

# Benchmark translation speed
polyglotx benchmark --language ar --count 100

# Compare engines
polyglotx benchmark --compare-engines --language ar

# Set default language
polyglotx config set language ar

# Show configuration
polyglotx config show

# Reset to defaults
polyglotx config reset

from flask import Flask, jsonify
from PolyglotX.handlers.error_formatter import JSONErrorFormatter
from PolyglotX.core.exception_handler import ExceptionHandler

app = Flask(__name__)
formatter = JSONErrorFormatter(language='ar')

@app.errorhandler(Exception)
def handle_error(error):
    json_error = formatter.format(error)
    return jsonify(json_error), 500

@app.route('/api/data')
def get_data():
    # Errors are automatically formatted in Arabic JSON
    result = 10 / 0
    return jsonify(result)

from PolyglotX.core.translator import Translator

class MultiLangErrorHandler:
    def __init__(self):
        self.translators = {
            'ar': Translator('ar'),
            'tr': Translator('tr'),
            'ja': Translator('ja'),
            'zh': Translator('zh-CN')
        }
    
    def translate_error(self, error, user_language):
        translator = self.translators.get(user_language)
        if translator:
            return translator.translate(str(error))
        return str(error)

handler = MultiLangErrorHandler()
translated = handler.translate_error(exception, 'ar')

from PolyglotX.core.context_manager import translated_errors

with translated_errors(language='ar', show_credits=True):
    # All errors in this block are translated
    x = undefined_variable
    y = 10 / 0

# Outside the context, errors are normal
z = normal_error  # Regular Python error

from PolyglotX.core.exception_handler import ChainedExceptionHandler
from PolyglotX.handlers.output_handler import (
    FileOutputHandler,
    EmailOutputHandler,
    WebhookOutputHandler
)

# Create processing pipeline
handler = ChainedExceptionHandler(language='ar')

# Add file logging
handler.add_handler(FileOutputHandler(
    language='ar',
    file_path='errors.log'
))

# Add email notifications for critical errors
handler.add_handler(EmailOutputHandler(
    language='ar',
    smtp_server='smtp.gmail.com',
    recipients=['admin@example.com']
))

# Add Slack webhook
handler.add_handler(WebhookOutputHandler(
    language='ar',
    webhook_url='https://hooks.slack.com/...'
))

handler.install()

import PolyglotX

# Set global defaults
PolyglotX.set_default_language('ar')
PolyglotX.set_show_credits(True)
PolyglotX.set_auto_exit(False)

# Configure caching
PolyglotX.set_cache_enabled(True)
PolyglotX.set_cache_size(10000)
PolyglotX.set_cache_ttl(3600)  # 1 hour

# Configure translation engines
PolyglotX.set_preferred_engine('google')
PolyglotX.set_engine_timeout(10.0)
PolyglotX.set_retry_attempts(3)

# Create polyglotx.yaml
default:
  language: ar
  show_credits: true
  auto_exit: false

cache:
  enabled: true
  size: 10000
  ttl: 3600

engines:
  preferred: google
  timeout: 10.0
  retry: 3
  fallback: [mymemory, libre]

output:
  format: colored
  file: errors.log
  
translation:
  quality_threshold: 0.8
  preserve_variables: true
  translate_stack_trace: true

# Check internet connection
import requests
try:
    requests.get('https://translate.google.com', timeout=5)
    print("Connection OK")
except:
    print("Connection failed")

# Test translator directly
from PolyglotX.core.translator import Translator
translator = Translator('ar')
result = translator.translate("test")
print(result)

# Ensure UTF-8 encoding
import sys
sys.stdout.reconfigure(encoding='utf-8')

# For file output
with open('errors.log', 'w', encoding='utf-8') as f:
    f.write(translated_error)

# Clear cache
from PolyglotX.core.translator import CachedTranslator
translator = CachedTranslator('ar')
translator.clear_cache()

# Disable cache temporarily
translator.set_cache_enabled(False)