def safe_int(s):
    try:
        return int(s)
    except ValueError:
        return None

print(safe_int('123'))  # 123
print(safe_int('abc'))  # None

def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        print("تقسیم بر صفر امکان‌پذیر نیست")
        return None

print(safe_divide(10, 2))  # 5.0
print(safe_divide(10, 0))  # None

def safe_get(lst, index):
    try:
        return lst[index]
    except IndexError:
        print("ایندکس نامعتبر")
        return None

print(safe_get([1,2,3], 1))   # 2
print(safe_get([1,2,3], 10))  # None

def safe_dict_get(d, key):
    try:
        return d[key]
    except KeyError:
        return "NotFound"

data = {'name': 'Ali', 'age': 25}
print(safe_dict_get(data, 'name'))     # Ali
print(safe_dict_get(data, 'address'))  # NotFound

def read_file_safe(filename):
    try:
        with open(filename, 'r', encoding='utf-8') as f:
            return f.read()
    except FileNotFoundError:
        print(f"فایل {filename} یافت نشد")
        return ""
    except PermissionError:
        print(f"دسترسی به فایل {filename} وجود ندارد")
        return ""
    except Exception as e:
        print(f"خطای غیرمنتظره: {e}")
        return ""

def write_file_safe(filename, content):
    try:
        with open(filename, 'w', encoding='utf-8') as f:
            f.write(content)
        return True
    except PermissionError:
        print("دسترسی برای نوشتن در فایل وجود ندارد")
        return False
    except Exception as e:
        print(f"خطا در نوشتن فایل: {e}")
        return False

write_file_safe('test.txt', 'Hello World')

def safe_average(numbers):
    valid_numbers = []
    for num in numbers:
        try:
            valid_numbers.append(float(num))
        except (ValueError, TypeError):
            continue
    
    try:
        return sum(valid_numbers) / len(valid_numbers)
    except ZeroDivisionError:
        print("لیست خالی است")
        return 0

print(safe_average([1, 2, 3]))      # 2.0
print(safe_average([]))             # 0
print(safe_average([1, 'a', 3]))    # 2.0

def validate_age(age):
    if age < 0:
        raise ValueError("سن نمی‌تواند منفی باشد")
    if age > 150:
        raise ValueError("سن نمی‌تواند بیشتر از 150 باشد")
    return "سن معتبر است"

try:
    print(validate_age(25))   # سن معتبر است
    print(validate_age(-5))   # ValueError
except ValueError as e:
    print(f"خطا: {e}")

def calculator(a, b, op):
    try:
        a, b = float(a), float(b)
        if op == '+':
            return a + b
        elif op == '-':
            return a - b
        elif op == '*':
            return a * b
        elif op == '/':
            return a / b
        else:
            raise ValueError("عملگر نامعتبر")
    except ValueError as e:
        print(f"خطا: {e}")
        return None
    except ZeroDivisionError:
        print("خطا: تقسیم بر صفر")
        return None
    except Exception as e:
        print(f"خطای غیرمنتظره: {e}")
        return None

print(calculator(10, 2, '+'))  # 12.0
print(calculator(10, 0, '/'))  # None

import json

def count_json_items(json_str):
    try:
        data = json.loads(json_str)
        if isinstance(data, list):
            return len(data)
        else:
            print("JSON باید لیست باشد")
            return 0
    except json.JSONDecodeError:
        print("JSON نامعتبر است")
        return 0
    except Exception as e:
        print(f"خطا: {e}")
        return 0

print(count_json_items('[1,2,3]'))     # 3
print(count_json_items('{invalid}'))   # 0

import sqlite3

def fetch_data_safe(db_name, query):
    conn = None
    try:
        conn = sqlite3.connect(db_name)
        cursor = conn.cursor()
        cursor.execute(query)
        results = cursor.fetchall()
        return results
    except sqlite3.Error as e:
        print(f"خطای دیتابیس: {e}")
        return []
    except Exception as e:
        print(f"خطای غیرمنتظره: {e}")
        return []
    finally:
        if conn:
            conn.close()
            print("اتصال بسته شد")

# مثال استفاده:
# data = fetch_data_safe('test.db', 'SELECT * FROM users')

def retry_function(func, *args, max_attempts=3):
    for attempt in range(1, max_attempts + 1):
        try:
            result = func(*args)
            print(f"موفق در تلاش {attempt}")
            return result
        except Exception as e:
            print(f"تلاش {attempt} ناموفق: {e}")
            if attempt == max_attempts:
                print("عملیات ناموفق پس از 3 تلاش")
                return None

# مثال:
def unstable_func():
    import random
    if random.random() < 0.7:
        raise Exception("خطای تصادفی")
    return "موفق"

retry_function(unstable_func)

from datetime import datetime

class ErrorLogger:
    def __init__(self, log_file='errors.log'):
        self.log_file = log_file
    
    def log_error(self, error_type, message):
        try:
            timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            log_entry = f"[{timestamp}] {error_type}: {message}\n"
            
            with open(self.log_file, 'a', encoding='utf-8') as f:
                f.write(log_entry)
            
            print(f"خطا ثبت شد: {error_type}")
        except PermissionError:
            print("خطا: دسترسی به فایل لاگ وجود ندارد")
        except Exception as e:
            print(f"خطا در ثبت لاگ: {e}")

# استفاده:
logger = ErrorLogger()
try:
    x = 10 / 0
except ZeroDivisionError as e:
    logger.log_error('ZeroDivisionError', str(e))

class InsufficientFundsError(Exception):
    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
        super().__init__(f"موجودی ناکافی: دارایی={balance}، درخواست={amount}")

class BankAccount:
    def __init__(self, balance=0):
        self.balance = balance
    
    def withdraw(self, amount):
        if amount > self.balance:
            raise InsufficientFundsError(self.balance, amount)
        self.balance -= amount
        return f"برداشت موفق. موجودی: {self.balance}"

# استفاده:
account = BankAccount(1000)
try:
    print(account.withdraw(500))   # موفق
    print(account.withdraw(1000))  # خطا
except InsufficientFundsError as e:
    print(f"خطا: {e}")

def merge_files(input_files, output_file):
    combined_content = []
    
    for filename in input_files:
        try:
            with open(filename, 'r', encoding='utf-8') as f:
                content = f.read()
                combined_content.append(f"=== {filename} ===\n{content}\n")
        except FileNotFoundError:
            print(f"فایل {filename} یافت نشد، نادیده گرفته شد")
        except UnicodeDecodeError:
            print(f"خطای کدگذاری در {filename}")
        except Exception as e:
            print(f"خطا در خواندن {filename}: {e}")
    
    try:
        with open(output_file, 'w', encoding='utf-8') as f:
            f.write('\n'.join(combined_content))
        print(f"فایل‌ها با موفقیت در {output_file} ترکیب شدند")
        return True
    except Exception as e:
        print(f"خطا در نوشتن فایل خروجی: {e}")
        return False

# merge_files(['file1.txt', 'file2.txt'], 'merged.txt')

import re

class InvalidEmailError(Exception):
    pass

class WeakPasswordError(Exception):
    pass

class InvalidPhoneError(Exception):
    pass

class FormValidator:
    @staticmethod
    def validate_email(email):
        pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
        if not re.match(pattern, email):
            raise InvalidEmailError("فرمت ایمیل نامعتبر است")
    
    @staticmethod
    def validate_password(password):
        if len(password) < 8:
            raise WeakPasswordError("رمز باید حداقل 8 کاراکتر باشد")
        if not any(c.isdigit() for c in password):
            raise WeakPasswordError("رمز باید شامل عدد باشد")
    
    @staticmethod
    def validate_phone(phone):
        if not phone.isdigit() or len(phone) != 11:
            raise InvalidPhoneError("شماره تلفن باید 11 رقم باشد")
    
    def validate_form(self, email, password, phone):
        try:
            self.validate_email(email)
            self.validate_password(password)
            self.validate_phone(phone)
            return "فرم معتبر است"
        except (InvalidEmailError, WeakPasswordError, InvalidPhoneError) as e:
            return f"خطای اعتبارسنجی: {e}"

# استفاده:
validator = FormValidator()
print(validator.validate_form('test@example.com', 'pass123', '09123456789'))

import requests

def download_file(url, filename):
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()  # خطا برای کدهای 4xx/5xx
        
        with open(filename, 'wb') as f:
            f.write(response.content)
        
        print(f"فایل با موفقیت دانلود شد: {filename}")
        return True
        
    except requests.exceptions.Timeout:
        print("خطا: زمان اتصال به پایان رسید")
        return False
    except requests.exceptions.ConnectionError:
        print("خطا: عدم اتصال به اینترنت")
        return False
    except requests.exceptions.HTTPError as e:
        print(f"خطای HTTP: {e}")
        return False
    except PermissionError:
        print("خطا: دسترسی برای ذخیره فایل وجود ندارد")
        return False
    except Exception as e:
        print(f"خطای غیرمنتظره: {e}")
        return False

# download_file('https://example.com/file.pdf', 'output.pdf')

import time

class CacheExpiredError(Exception):
    pass

class TimedCache:
    def __init__(self):
        self.cache = {}
    
    def set(self, key, value, ttl=60):
        try:
            expiry_time = time.time() + ttl
            self.cache[key] = {'value': value, 'expiry': expiry_time}
            print(f"کلید '{key}' با TTL {ttl} ثانیه ذخیره شد")
        except Exception as e:
            print(f"خطا در ذخیره کش: {e}")
    
    def get(self, key):
        try:
            if key not in self.cache:
                raise KeyError(f"کلید '{key}' در کش وجود ندارد")
            
            item = self.cache[key]
            if time.time() > item['expiry']:
                del self.cache[key]
                raise CacheExpiredError(f"کش '{key}' منقضی شده است")
            
            return item['value']
        except (KeyError, CacheExpiredError) as e:
            print(f"خطا: {e}")
            return None

# استفاده:
cache = TimedCache()
cache.set('user', {'name': 'Ali'}, ttl=5)
print(cache.get('user'))  # {'name': 'Ali'}
time.sleep(6)
print(cache.get('user'))  # None (منقضی شده)

import csv
import json

def csv_to_json_filtered(csv_file, json_file, filter_column, filter_value):
    try:
        with open(csv_file, 'r', encoding='utf-8') as f:
            reader = csv.DictReader(f)
            
            # بررسی وجود ستون
            if filter_column not in reader.fieldnames:
                raise ValueError(f"ستون '{filter_column}' در فایل CSV وجود ندارد")
            
            # فیلتر کردن داده‌ها
            filtered_data = [
                row for row in reader 
                if row.get(filter_column) == filter_value
            ]
            
            if not filtered_data:
                print(f"هیچ داده‌ای با مقدار '{filter_value}' یافت نشد")
            
        # ذخیره در JSON
        with open(json_file, 'w', encoding='utf-8') as f:
            json.dump(filtered_data, f, ensure_ascii=False, indent=2)
        
        print(f"{len(filtered_data)} رکورد در {json_file} ذخیره شد")
        return True
        
    except FileNotFoundError:
        print(f"فایل {csv_file} یافت نشد")
        return False
    except csv.Error as e:
        print(f"خطای CSV: {e}")
        return False
    except ValueError as e:
        print(f"خطا: {e}")
        return False
    except Exception as e:
        print(f"خطای غیرمنتظره: {e}")
        return False

# csv_to_json_filtered('users.csv', 'output.json', 'age', '25')

import sqlite3

class DatabaseTransaction:
    def __init__(self, db_name):
        self.db_name = db_name
        self.conn = None
    
    def execute_transaction(self, queries):
        try:
            self.conn = sqlite3.connect(self.db_name)
            cursor = self.conn.cursor()
            
            # اجرای کوئری‌ها
            for query in queries:
                cursor.execute(query)
            
        except sqlite3.Error as e:
            print(f"خطای دیتابیس: {e}")
            if self.conn:
                self.conn.rollback()
                print("تمام تغییرات Rollback شد")
            return False
            
        except Exception as e:
            print(f"خطای غیرمنتظره: {e}")
            if self.conn:
                self.conn.rollback()
            return False
            
        else:
            # اگر خطایی نبود، commit کن
            self.conn.commit()
            print("Transaction با موفقیت انجام شد")
            return True
            
        finally:
            # همیشه اتصال را ببند
            if self.conn:
                self.conn.close()
                print("اتصال دیتابیس بسته شد")

# استفاده:
# db = DatabaseTransaction('test.db')
# queries = [
#     "INSERT INTO users (name, age) VALUES ('Ali', 25)",
#     "INSERT INTO users (name, age) VALUES ('Sara', 30)"
# ]
# db.execute_transaction(queries)