parsikit 2.1.0__tar.gz

parsikit-2.1.0/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: parsikit
+Version: 2.1.0
+Summary: A comprehensive and pure Python library for Persian data formatting, validation, and graphical reshaping.
+Author: Ali Kamrani
+Author-email: Ali Kamrani <kamrani.exe@gmail.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: Persian
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: requires-python
+
+# ParsiKit
+
+A lightweight, zero-dependency, pure Python library designed for Persian text standardization, layout reshaping for legacy graphics engines, financial calculations, and Iranian standard format validations.
+
+---
+
+## Key Features
+
+- **Text Normalization & Correction**: Character mapping (Arabic `ي`/`ك` to Persian `ی`/`ک`), robust Zero-Width Non-Joiner (ZWNJ / نیم‌فاصله) formatting for verbs and suffixes, diacritics stripping, and English-to-Persian keyboard layout correction.
+- **Digit & Number Conversions**: Convert digits between English, Persian, and Arabic formats, and translate numbers up to quadrillions into written Persian words.
+- **Currency & Financial Utilities**: Thousand-separator formatting, Rial and Toman conversions, VAT calculator, loan monthly installment calculator, and verbal currency representations.
+- **Iranian Standards Validators**: Real-time validation and clean formatting for National Codes, Mobile Numbers, Bank Cards (with Luhn checksum validation), and Sheba (IBAN) codes.
+- **Graphical Text Reshaper**: A zero-dependency Persian reshaper that connects letters and handles RTL bidirectional flow for rendering text on Left-to-Right graphics engines (such as PIL/Pillow, Unity, Pygame, OpenCV, Matplotlib, or After Effects).
+
+---
+
+## Installation
+
+You can install the package directly from source:
+
+```bash
+git clone https://github.com/MRThugh/ParsiKit.git
+cd ParsiKit
+pip install .
+```
+
+---
+
+## Quick Start & Examples
+
+### 1. Text Normalization & Keyboard Layout Correction
+
+```python
+import parsikit
+
+# Standardize Persian characters and ZWNJ formatting
+raw_text = "ي كافيه ك کتاب ها ميباشد سَلامٌ"
+standardized = parsikit.standardize_persian(raw_text)
+print(standardized)  # "ی کافیه ک کتاب‌ها میباشد سلام"
+
+# Strip diacritics (Harakat)
+clean_text = parsikit.strip_diacritics("سَلامٌ")
+print(clean_text)  # "سلام"
+
+# Correct mistyped English layout text (e.g., typing standard words on wrong layout)
+corrected = parsikit.correct_keyboard_layout("sghl")
+print(corrected)  # "سلام"
+```
+
+### 2. Digit Conversion & Verbal Number Representation
+
+```python
+import parsikit
+
+# Convert digits
+fa_digits = parsikit.english_to_persian("Price: 12500 Toman")
+print(fa_digits)  # "Price: ۱۲۵۰۰ Toman"
+
+# Convert numeric values to written Persian words
+words = parsikit.number_to_words(1453200)
+print(words)  # "یک میلیون و چهارصد و پنجاه و سه هزار و دویست"
+```
+
+### 3. Currency & Loan Installment Planning
+
+```python
+import parsikit
+
+# Format with thousands separators
+formatted = parsikit.format_currency("1500000", currency="toman", persian_digits=True)
+print(formatted)  # "۱،۵۰۰،۰۰۰ تومان"
+
+# Convert currency directly into words
+words = parsikit.format_currency_to_words(1000000, currency="toman")
+print(words)  # "یک میلیون تومان"
+
+# Add Value Added Tax (VAT - Default is 10%)
+total_with_tax = parsikit.add_tax_and_toll(100000)
+print(total_with_tax)  # 110000
+
+# Calculate monthly loan installments (e.g., 10M loan at 18% interest over 12 months)
+monthly_payment = parsikit.calculate_installments(10000000, annual_interest_rate=18.0, months=12)
+print(monthly_payment)  # 916799
+```
+
+### 4. Identity & Banking Validators
+
+```python
+import parsikit
+
+# National Code Checksum Validation & Formatting
+if parsikit.is_valid_national_code("7730123452"):
+    formatted_nc = parsikit.format_national_code("7730123452")
+    print(formatted_nc)  # "773-012345-2"
+
+# Mobile Normalization (Standardizes input with various country code formats)
+if parsikit.is_valid_mobile("+989123456789"):
+    local_mobile = parsikit.normalize_mobile("+989123456789", prefix="0")
+    print(local_mobile)  # "09123456789"
+
+# Luhn Checksum Card Verification
+is_card_valid = parsikit.is_valid_card_number("6037991122334455")
+print(is_card_valid)  # True
+
+# Standard Sheba (IBAN) Checksum Validation & Formatting
+if parsikit.is_valid_sheba("050170000000123456789012"):
+    readable_sheba = parsikit.format_sheba("050170000000123456789012", format_type="spaced")
+    print(readable_sheba)  # "IR05 0170 0000 0012 3456 7890 12"
+```
+
+### 5. Layout Reshaping for Graphical Renderers
+
+```python
+import parsikit
+
+# Forces Left-to-Right layout simulation engines (like PIL/Pillow or Pygame)
+# to render Persian words connected and beautifully aligned.
+graphical_text = parsikit.reshape_for_graphics("سلام Hello جهان", reverse=True)
+print(graphical_text)  # "ﻡﻼﺳ Hello ﻥﺎﻬﺟ"
+```
+
+---
+
+## Running Tests
+
+To verify package integrity, execute the comprehensive test suite locally:
+
+```bash
+python test.py
+```
+
+---
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

parsikit-2.1.0/README.md

@@ -0,0 +1,136 @@
+# ParsiKit
+
+A lightweight, zero-dependency, pure Python library designed for Persian text standardization, layout reshaping for legacy graphics engines, financial calculations, and Iranian standard format validations.
+
+---
+
+## Key Features
+
+- **Text Normalization & Correction**: Character mapping (Arabic `ي`/`ك` to Persian `ی`/`ک`), robust Zero-Width Non-Joiner (ZWNJ / نیم‌فاصله) formatting for verbs and suffixes, diacritics stripping, and English-to-Persian keyboard layout correction.
+- **Digit & Number Conversions**: Convert digits between English, Persian, and Arabic formats, and translate numbers up to quadrillions into written Persian words.
+- **Currency & Financial Utilities**: Thousand-separator formatting, Rial and Toman conversions, VAT calculator, loan monthly installment calculator, and verbal currency representations.
+- **Iranian Standards Validators**: Real-time validation and clean formatting for National Codes, Mobile Numbers, Bank Cards (with Luhn checksum validation), and Sheba (IBAN) codes.
+- **Graphical Text Reshaper**: A zero-dependency Persian reshaper that connects letters and handles RTL bidirectional flow for rendering text on Left-to-Right graphics engines (such as PIL/Pillow, Unity, Pygame, OpenCV, Matplotlib, or After Effects).
+
+---
+
+## Installation
+
+You can install the package directly from source:
+
+```bash
+git clone https://github.com/MRThugh/ParsiKit.git
+cd ParsiKit
+pip install .
+```
+
+---
+
+## Quick Start & Examples
+
+### 1. Text Normalization & Keyboard Layout Correction
+
+```python
+import parsikit
+
+# Standardize Persian characters and ZWNJ formatting
+raw_text = "ي كافيه ك کتاب ها ميباشد سَلامٌ"
+standardized = parsikit.standardize_persian(raw_text)
+print(standardized)  # "ی کافیه ک کتاب‌ها میباشد سلام"
+
+# Strip diacritics (Harakat)
+clean_text = parsikit.strip_diacritics("سَلامٌ")
+print(clean_text)  # "سلام"
+
+# Correct mistyped English layout text (e.g., typing standard words on wrong layout)
+corrected = parsikit.correct_keyboard_layout("sghl")
+print(corrected)  # "سلام"
+```
+
+### 2. Digit Conversion & Verbal Number Representation
+
+```python
+import parsikit
+
+# Convert digits
+fa_digits = parsikit.english_to_persian("Price: 12500 Toman")
+print(fa_digits)  # "Price: ۱۲۵۰۰ Toman"
+
+# Convert numeric values to written Persian words
+words = parsikit.number_to_words(1453200)
+print(words)  # "یک میلیون و چهارصد و پنجاه و سه هزار و دویست"
+```
+
+### 3. Currency & Loan Installment Planning
+
+```python
+import parsikit
+
+# Format with thousands separators
+formatted = parsikit.format_currency("1500000", currency="toman", persian_digits=True)
+print(formatted)  # "۱،۵۰۰،۰۰۰ تومان"
+
+# Convert currency directly into words
+words = parsikit.format_currency_to_words(1000000, currency="toman")
+print(words)  # "یک میلیون تومان"
+
+# Add Value Added Tax (VAT - Default is 10%)
+total_with_tax = parsikit.add_tax_and_toll(100000)
+print(total_with_tax)  # 110000
+
+# Calculate monthly loan installments (e.g., 10M loan at 18% interest over 12 months)
+monthly_payment = parsikit.calculate_installments(10000000, annual_interest_rate=18.0, months=12)
+print(monthly_payment)  # 916799
+```
+
+### 4. Identity & Banking Validators
+
+```python
+import parsikit
+
+# National Code Checksum Validation & Formatting
+if parsikit.is_valid_national_code("7730123452"):
+    formatted_nc = parsikit.format_national_code("7730123452")
+    print(formatted_nc)  # "773-012345-2"
+
+# Mobile Normalization (Standardizes input with various country code formats)
+if parsikit.is_valid_mobile("+989123456789"):
+    local_mobile = parsikit.normalize_mobile("+989123456789", prefix="0")
+    print(local_mobile)  # "09123456789"
+
+# Luhn Checksum Card Verification
+is_card_valid = parsikit.is_valid_card_number("6037991122334455")
+print(is_card_valid)  # True
+
+# Standard Sheba (IBAN) Checksum Validation & Formatting
+if parsikit.is_valid_sheba("050170000000123456789012"):
+    readable_sheba = parsikit.format_sheba("050170000000123456789012", format_type="spaced")
+    print(readable_sheba)  # "IR05 0170 0000 0012 3456 7890 12"
+```
+
+### 5. Layout Reshaping for Graphical Renderers
+
+```python
+import parsikit
+
+# Forces Left-to-Right layout simulation engines (like PIL/Pillow or Pygame)
+# to render Persian words connected and beautifully aligned.
+graphical_text = parsikit.reshape_for_graphics("سلام Hello جهان", reverse=True)
+print(graphical_text)  # "ﻡﻼﺳ Hello ﻥﺎﻬﺟ"
+```
+
+---
+
+## Running Tests
+
+To verify package integrity, execute the comprehensive test suite locally:
+
+```bash
+python test.py
+```
+
+---
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

parsikit-2.1.0/parsikit/__init__.py

@@ -0,0 +1,58 @@
+"""
+parsikit
+~~~~~~~~
+A pure Python library for Persian data formatting, validation, and normalization.
+"""
+
+from parsikit.text import standardize_persian, strip_diacritics, is_persian, correct_keyboard_layout
+from parsikit.number import english_to_persian, persian_to_english, number_to_words
+from parsikit.currency import (
+    format_currency,
+    rial_to_toman,
+    toman_to_rial,
+    format_currency_to_words,
+    add_tax_and_toll,
+    calculate_installments,
+)
+from parsikit.validators import (
+    is_valid_national_code,
+    format_national_code,
+    is_valid_mobile,
+    normalize_mobile,
+    is_valid_card_number,
+    format_card_number,
+    is_valid_sheba,
+    format_sheba,
+)
+from parsikit.reshaper import reshape_for_graphics
+
+__version__ = "2.1.0"
+__all__ = [
+    # text
+    "standardize_persian",
+    "strip_diacritics",
+    "is_persian",
+    "correct_keyboard_layout",
+    # number
+    "english_to_persian",
+    "persian_to_english",
+    "number_to_words",
+    # currency
+    "format_currency",
+    "rial_to_toman",
+    "toman_to_rial",
+    "format_currency_to_words",
+    "add_tax_and_toll",
+    "calculate_installments",
+    # validators
+    "is_valid_national_code",
+    "format_national_code",
+    "is_valid_mobile",
+    "normalize_mobile",
+    "is_valid_card_number",
+    "format_card_number",
+    "is_valid_sheba",
+    "format_sheba",
+    # reshaper
+    "reshape_for_graphics",
+]

parsikit-2.1.0/parsikit/currency.py

@@ -0,0 +1,128 @@
+"""
+parsikit.currency
+~~~~~~~~~~~~~~~~~
+Monetary utilities, unit conversions, tax calculations, and loan installment planning.
+"""
+
+from __future__ import annotations
+from parsikit.number import number_to_words
+
+_CURRENCY_LABELS = {
+    "toman": "تومان",
+    "rial": "ریال",
+}
+
+
+def format_currency(
+    amount: int | str,
+    currency: str = "toman",
+    *,
+    persian_digits: bool = False,
+) -> str:
+    """Format a numeric amount as a readable currency with thousands separators."""
+    currency = currency.lower()
+    if currency not in _CURRENCY_LABELS:
+        raise ValueError(f"Unknown currency '{currency}'")
+
+    _persian_to_ascii = str.maketrans("۰۱۲۳۴۵۶۷۸۹٠١٢٣٤٥٦٧٨٩", "01234567890123456789")
+    normalized = str(amount).translate(_persian_to_ascii)
+
+    try:
+        value = int(normalized)
+    except ValueError:
+        raise ValueError(f"Cannot convert '{amount}' to an integer amount.") from None
+
+    label = _CURRENCY_LABELS[currency]
+
+    if persian_digits:
+        _to_persian = str.maketrans("0123456789,", "۰۱۲۳۴۵۶۷۸۹،")
+        formatted = f"{value:,}".translate(_to_persian)
+        return f"{formatted} {label}"
+
+    return f"{value:,} {label}"
+
+
+def rial_to_toman(amount: int) -> int:
+    """Convert Iranian Rial to Toman."""
+    if amount < 0:
+        raise ValueError("Amount must be non-negative.")
+    return amount // 10
+
+
+def toman_to_rial(amount: int) -> int:
+    """Convert Toman to Iranian Rial."""
+    if amount < 0:
+        raise ValueError("Amount must be non-negative.")
+    return amount * 10
+
+
+def format_currency_to_words(amount: int | str, currency: str = "toman") -> str:
+    """Convert monetary values to written Persian words with proper currency label."""
+    currency = currency.lower()
+    if currency not in _CURRENCY_LABELS:
+        raise ValueError(f"Unknown currency '{currency}'")
+
+    _persian_to_ascii = str.maketrans("۰۱۲۳۴۵۶۷۸۹٠١٢٣٤٥٦٧٨٩", "01234567890123456789")
+    normalized = str(amount).translate(_persian_to_ascii)
+    try:
+        value = int(normalized)
+    except ValueError:
+        raise ValueError(f"Cannot convert '{amount}' to an integer amount.") from None
+
+    words_part = number_to_words(value)
+    label = _CURRENCY_LABELS[currency]
+    return f"{words_part} {label}"
+
+
+def add_tax_and_toll(amount: int | str, tax_rate: float = 0.10) -> int:
+    """Calculate total amount including Value Added Tax (VAT). Default is 10%.
+
+    Args:
+        amount:   The price amount as int or string.
+        tax_rate: Tax rate as float (e.g. 0.10 for 10%).
+
+    Returns:
+        The total price including tax as an integer.
+    """
+    _persian_to_ascii = str.maketrans("۰۱۲۳۴۵۶۷۸۹٠١٢٣٤٥٦٧٨٩", "01234567890123456789")
+    normalized = str(amount).translate(_persian_to_ascii)
+    try:
+        val = int(normalized)
+    except ValueError:
+        raise ValueError(f"Invalid numeric input '{amount}' for tax calculations.") from None
+
+    if val < 0:
+        raise ValueError("Amount must be non-negative.")
+
+    return int(val * (1 + tax_rate))
+
+
+def calculate_installments(principal: int | str, annual_interest_rate: float, months: int) -> int:
+    """Calculate the monthly installment amount for loan amortization.
+
+    Args:
+        principal:            The total loan amount.
+        annual_interest_rate: Annual interest percentage (e.g. 18.0 or 23.0).
+        months:               Number of payment months.
+
+    Returns:
+        The exact monthly installment amount as integer.
+    """
+    _persian_to_ascii = str.maketrans("۰۱۲۳۴۵۶۷۸۹٠١٢٣٤٥٦٧٨٩", "01234567890123456789")
+    normalized = str(principal).translate(_persian_to_ascii)
+    try:
+        p = int(normalized)
+    except ValueError:
+        raise ValueError(f"Invalid loan principal '{principal}'.") from None
+
+    if p <= 0 or months <= 0:
+        raise ValueError("Loan principal and months must be greater than zero.")
+
+    if annual_interest_rate == 0:
+        return int(p / months)
+
+    # Convert yearly percentage rate to a monthly decimal rate
+    r = (annual_interest_rate / 100) / 12
+    numerator = p * r * ((1 + r) ** months)
+    denominator = ((1 + r) ** months) - 1
+    return int(numerator / denominator)

parsikit-2.1.0/parsikit/number.py

@@ -0,0 +1,133 @@
+"""
+parsikit.number
+~~~~~~~~~~~~~~~
+Number conversion utilities and textual representations of numbers.
+"""
+
+_TO_PERSIAN_TABLE = str.maketrans(
+    {
+        "0": "\u06F0", "1": "\u06F1", "2": "\u06F2",
+        "3": "\u06F3", "4": "\u06F4", "5": "\u06F5",
+        "6": "\u06F6", "7": "\u06F7", "8": "\u06F8",
+        "9": "\u06F9",
+        "\u0660": "\u06F0", "\u0661": "\u06F1", "\u0662": "\u06F2",
+        "\u0663": "\u06F3", "\u0664": "\u06F4", "\u0665": "\u06F5",
+        "\u0666": "\u06F6", "\u0667": "\u06F7", "\u0668": "\u06F8",
+        "\u0669": "\u06F9",
+    }
+)
+
+_TO_ENGLISH_TABLE = str.maketrans(
+    {
+        "\u06F0": "0", "\u06F1": "1", "\u06F2": "2",
+        "\u06F3": "3", "\u06F4": "4", "\u06F5": "5",
+        "\u06F6": "6", "\u06F7": "7", "\u06F8": "8",
+        "\u06F9": "9",
+        "\u0660": "0", "\u0661": "1", "\u0662": "2",
+        "\u0663": "3", "\u0664": "4", "\u0665": "5",
+        "\u0666": "6", "\u0667": "7", "\u0668": "8",
+        "\u0669": "9",
+    }
+)
+
+
+def english_to_persian(text: str) -> str:
+    """Convert English/Arabic digits inside a string to Persian equivalents."""
+    if not text:
+        return text
+    return text.translate(_TO_PERSIAN_TABLE)
+
+
+def persian_to_english(text: str) -> str:
+    """Convert Persian/Arabic digits inside a string to English equivalents."""
+    if not text:
+        return text
+    return text.translate(_TO_ENGLISH_TABLE)
+
+
+def number_to_words(number: int | str) -> str:
+    """Convert numeric values to written Persian words."""
+    if isinstance(number, str):
+        clean_num = number.translate(_TO_ENGLISH_TABLE)
+        try:
+            num = int(clean_num)
+        except ValueError:
+            raise ValueError(f"Cannot convert '{number}' to a valid integer.") from None
+    else:
+        num = int(number)
+
+    if num == 0:
+        return "صفر"
+
+    is_negative = False
+    if num < 0:
+        is_negative = True
+        num = abs(num)
+
+    ones = {
+        1: "یک", 2: "دو", 3: "سه", 4: "چهار", 5: "پنج",
+        6: "شش", 7: "هفت", 8: "هشت", 9: "نه"
+    }
+    tens = {
+        10: "ده", 11: "یازده", 12: "دوازده", 13: "سیزده", 14: "چهارده",
+        15: "پانزده", 16: "شانزده", 17: "هفده", 18: "هجده", 19: "نوزده"
+    }
+    twenties = {
+        2: "بیست", 3: "سی", 4: "چهل", 5: "پنجاه",
+        6: "شصت", 7: "هفتاد", 8: "هشتاد", 9: "نود"
+    }
+    hundreds = {
+        1: "یکصد", 2: "دویست", 3: "سیصد", 4: "چهارصد", 5: "پانصد",
+        6: "ششصد", 7: "هفتصد", 8: "هشتصد", 9: "نهصد"
+    }
+    thousands = [
+        "", "هزار", "میلیون", "میلیارد", "تریلیون", "کوآدریلیون"
+    ]
+
+    def _convert_group(n: int) -> str:
+        parts = []
+        h = n // 100
+        t_o = n % 100
+        
+        if h > 0:
+            parts.append(hundreds[h])
+            
+        if t_o > 0:
+            if 10 <= t_o <= 19:
+                parts.append(tens[t_o])
+            else:
+                t = t_o // 10
+                o = t_o % 10
+                if t > 0:
+                    parts.append(twenties[t])
+                if o > 0:
+                    parts.append(ones[o])
+                    
+        return " و ".join(parts)
+
+    chunks = []
+    temp = num
+    while temp > 0:
+        chunks.append(temp % 1000)
+        temp //= 1000
+
+    words_list = []
+    for i, chunk in enumerate(chunks):
+        if chunk > 0:
+            chunk_word = _convert_group(chunk)
+            unit = thousands[i]
+            if unit:
+                if i == 1 and chunk == 1:
+                    words_list.append(unit)
+                else:
+                    words_list.append(f"{chunk_word} {unit}".strip())
+            else:
+                words_list.append(chunk_word)
+
+    words_list.reverse()
+    result = " و ".join(words_list)
+    
+    if is_negative:
+        result = "منفی " + result
+        
+    return result

parsikit-2.1.0/parsikit/reshaper.py

@@ -0,0 +1,191 @@
+"""
+parsikit.reshaper
+~~~~~~~~~~~~~~~~~
+A lightweight, zero-dependency Persian text shaper and layout reorganizer for graphical applications.
+"""
+
+from __future__ import annotations
+
+# Standard Persian and Arabic characters presentation forms mapping
+# Format: 'char': (Isolated, Initial, Medial, Final, connects_right, connects_left)
+_SHAPES: dict[str, tuple[str, str, str, str, bool, bool]] = {
+    'آ': ('\uFE81', '', '', '\uFE82', True, False),
+    'ا': ('\uFE8D', '', '', '\uFE8E', True, False),
+    'ب': ('\uFE8F', '\uFE91', '\uFE92', '\uFE90', True, True),
+    'پ': ('\uFB56', '\uFB58', '\uFB59', '\uFB57', True, True),
+    'ت': ('\uFE95', '\uFE97', '\uFE98', '\uFE96', True, True),
+    'ث': ('\uFE99', '\uFE9B', '\uFE9C', '\uFE9A', True, True),
+    'ج': ('\uFE9D', '\uFE9F', '\uFEA0', '\uFE9E', True, True),
+    'چ': ('\uFB7A', '\uFB7C', '\uFB7D', '\uFB7B', True, True),
+    'ح': ('\uFEA1', '\uFEA3', '\uFEA4', '\uFEA2', True, True),
+    'خ': ('\uFEA5', '\uFEA7', '\uFEA8', '\uFEA6', True, True),
+    'د': ('\uFEA9', '', '', '\uFEAA', True, False),
+    'ذ': ('\uFEAB', '', '', '\uFEAC', True, False),
+    'ر': ('\uFEAD', '', '', '\uFEAE', True, False),
+    'ز': ('\uFEAF', '', '', '\uFEB0', True, False),
+    'ژ': ('\uFB8A', '', '', '\uFB8B', True, False),
+    'س': ('\uFEB1', '\uFEB3', '\uFEB4', '\uFEB2', True, True),
+    'ش': ('\uFEB5', '\uFEB7', '\uFEB8', '\uFEB6', True, True),
+    'ص': ('\uFEB9', '\uFEBB', '\uFEBC', '\uFEBA', True, True),
+    'ض': ('\uFEBD', '\uFEBF', '\uFEC0', '\uFEBE', True, True),
+    'ط': ('\uFEC1', '\uFEC3', '\uFEC4', '\uFEC2', True, True),
+    'ظ': ('\uFEC5', '\uFEC7', '\uFEC8', '\uFEC6', True, True),
+    'ع': ('\uFEC9', '\uFECB', '\uFECC', '\uFECA', True, True),
+    'غ': ('\uFECD', '\uFECF', '\uFED0', '\uFECE', True, True),
+    'ف': ('\uFED1', '\uFED3', '\uFED4', '\uFED2', True, True),
+    'ق': ('\uFED5', '\uFED7', '\uFED8', '\uFED6', True, True),
+    'ک': ('\uFED9', '\uFEDB', '\uFEDC', '\uFEDA', True, True),
+    'گ': ('\uFB92', '\uFB94', '\uFB95', '\uFB93', True, True),
+    'ل': ('\uFEDD', '\uFEDF', '\uFEE0', '\uFEDE', True, True),
+    'م': ('\uFEE1', '\uFEE3', '\uFEE4', '\uFEE2', True, True),
+    'ن': ('\uFEE5', '\uFEE7', '\uFEE8', '\uFEE6', True, True),
+    'و': ('\uFEED', '', '', '\uFEEE', True, False),
+    'ه': ('\uFEE9', '\uFEEB', '\uFEEC', '\uFEEA', True, True),
+    'ی': ('\uFEF1', '\uFEF3', '\uFEF4', '\uFEF2', True, True),
+    'ئ': ('\uFE89', '\uFE8B', '\uFE8C', '\uFE8A', True, True),
+    'ء': ('\uFE80', '', '', '', False, False),
+    'ة': ('\uFE93', '', '', '\uFE94', True, False),
+}
+
+# Standard Lam-Alef ligatures: (Isolated, Final)
+_LIGATURES: dict[tuple[str, str], tuple[str, str]] = {
+    ('ل', 'ا'): ('\uFEFB', '\uFEFC'),
+    ('ل', 'آ'): ('\uFEF5', '\uFEF6'),
+    ('ل', 'أ'): ('\uFEF7', '\uFEF8'),
+    ('ل', 'إ'): ('\uFEF9', '\uFEFA'),
+}
+
+
+def _is_rtl_char(c: str) -> bool:
+    """Check if the given character belongs to the RTL Persian/Arabic Unicode blocks."""
+    o = ord(c)
+    return (0x0600 <= o <= 0x06FF) or (0xFB50 <= o <= 0xFDFF) or (0xFE70 <= o <= 0xFEFF) or c == '\u200C'
+
+
+def _reshape_word(text: str) -> str:
+    """Core logic to shape Persian letters according to their surrounding characters."""
+    n = len(text)
+    if n == 0:
+        return text
+
+    # Pre-process to identify Lam-Alef ligatures
+    processed_chars: list[str | tuple[str, str]] = []
+    i = 0
+    while i < n:
+        if i < n - 1 and (text[i], text[i+1]) in _LIGATURES:
+            processed_chars.append((text[i], text[i+1]))
+            i += 2
+        else:
+            processed_chars.append(text[i])
+            i += 1
+
+    n_processed = len(processed_chars)
+    result: list[str] = []
+
+    for i in range(n_processed):
+        item = processed_chars[i]
+
+        if isinstance(item, tuple):
+            # Process Lam-Alef ligature
+            connects_prev = False
+            if i > 0:
+                prev_item = processed_chars[i-1]
+                if not isinstance(prev_item, tuple) and prev_item in _SHAPES:
+                    connects_prev = _SHAPES[prev_item][5]  # connects_left of previous char
+            
+            isolated, final = _LIGATURES[item]
+            shape = final if connects_prev else isolated
+            result.append(shape)
+        else:
+            char = item
+            if char not in _SHAPES:
+                result.append(char)
+                continue
+
+            # Check previous character connection
+            connects_prev = False
+            if i > 0:
+                prev_item = processed_chars[i-1]
+                if isinstance(prev_item, tuple):
+                    # Previous was ligature (ends with Alef which doesn't connect left)
+                    connects_prev = False
+                elif prev_item in _SHAPES:
+                    connects_prev = _SHAPES[prev_item][5] and _SHAPES[char][4]
+
+            # Check next character connection
+            connects_next = False
+            if i < n_processed - 1:
+                next_item = processed_chars[i+1]
+                if isinstance(next_item, tuple):
+                    # Next is ligature (starts with Lam which connects right)
+                    connects_next = _SHAPES[char][5] and True
+                elif next_item in _SHAPES:
+                    connects_next = _SHAPES[char][5] and _SHAPES[next_item][4]
+
+            isolated, initial, medial, final, _, _ = _SHAPES[char]
+
+            if connects_prev and connects_next:
+                shape = medial or initial or isolated
+            elif connects_prev:
+                shape = final or isolated
+            elif connects_next:
+                shape = initial or isolated
+            else:
+                shape = isolated
+
+            result.append(shape)
+
+    return "".join(result)
+
+
+def reshape_for_graphics(text: str, reverse: bool = True) -> str:
+    """Prepare Persian text for rendering inside engines that lack RTL/Shaping support.
+
+    Separates RTL and LTR blocks, shapes the Persian characters, and optionally
+    reverses the RTL parts so they display in correct reading order on LTR canvases.
+
+    Args:
+        text:    Standard Persian/English input string.
+        reverse: If True, reverses the layout of the RTL chunks for LTR graphic cards.
+
+    Returns:
+        The transformed string containing reshaped presentation forms.
+    """
+    if not text:
+        return text
+
+    # Shape the standard letters
+    shaped_text = _reshape_word(text)
+
+    if not reverse:
+        return shaped_text
+
+    # Split string into RTL and LTR blocks to avoid reversing English text
+    blocks: list[tuple[bool, str]] = []
+    current_block: list[str] = []
+    current_is_rtl: bool | None = None
+
+    for char in shaped_text:
+        is_rtl = _is_rtl_char(char)
+        if current_is_rtl is None:
+            current_is_rtl = is_rtl
+            current_block.append(char)
+        elif is_rtl == current_is_rtl:
+            current_block.append(char)
+        else:
+            blocks.append((current_is_rtl, "".join(current_block)))
+            current_block = [char]
+            current_is_rtl = is_rtl
+
+    if current_block:
+        blocks.append((current_is_rtl, "".join(current_block)))
+
+    # Reconstruct blocks (reverse RTL character order while preserving LTR blocks)
+    output: list[str] = []
+    for is_rtl, block_text in blocks:
+        if is_rtl:
+            output.append("".join(reversed(block_text)))
+        else:
+            output.append(block_text)
+
+    return "".join(output)

parsikit-2.1.0/parsikit/text.py

@@ -0,0 +1,94 @@
+"""
+parsikit.text
+~~~~~~~~~~~~~
+Text standardization, normalization, and keyboard layout correction.
+"""
+
+import re
+
+# Table for converting Arabic characters to Persian equivalents
+_ARABIC_TO_PERSIAN_TABLE: dict[int, int] = str.maketrans(
+    {
+        "\u064A": "\u06CC",  # ي  → ی
+        "\u0649": "\u06CC",  # ى  → ی
+        "\u0643": "\u06A9",  # ك  → ک
+        "\u0660": "\u06F0", "\u0661": "\u06F1", "\u0662": "\u06F2", "\u0663": "\u06F3",
+        "\u0664": "\u06F4", "\u0665": "\u06F5", "\u0666": "\u06F6", "\u0667": "\u06F7",
+        "\u0668": "\u06F8", "\u0669": "\u06F9",
+        "\u06D5": "\u0647",  # ە → ه
+        "\u0629": "\u0647",  # ة → ه
+        "\u06C0": "\u0647\u0654",  # ۀ → هٔ
+    }
+)
+
+# Standard QWERTY keys mapped to standard Persian keyboard
+_QWERTY_TO_PERSIAN_MAP = {
+    'q': 'ض', 'w': 'ص', 'e': 'ث', 'r': 'ق', 't': 'ف', 'y': 'غ', 'u': 'ع', 'i': 'ه', 'o': 'خ', 'p': 'ح', '[': 'ج', ']': 'چ',
+    'a': 'ش', 's': 'س', 'd': 'ی', 'f': 'ب', 'g': 'ل', 'h': 'ا', 'j': 'ت', 'k': 'ن', 'l': 'م', ';': 'ک', "'": 'گ',
+    'z': 'ظ', 'x': 'ط', 'c': 'ز', 'v': 'ر', 'b': 'ذ', 'n': 'د', 'm': 'پ', ',': 'و',
+    'Q': 'ض', 'W': 'ص', 'E': 'ث', 'R': 'ق', 'T': 'ف', 'Y': 'غ', 'U': 'ع', 'I': 'ه', 'O': 'خ', 'P': 'ح', '{': 'ج', '}': 'چ',
+    'A': 'ش', 'S': 'س', 'D': 'ی', 'F': 'ب', 'G': 'ل', 'H': 'ا', 'J': 'ت', 'K': 'ن', 'L': 'م', ':': 'ک', '"': 'گ',
+    'Z': 'ظ', 'X': 'ط', 'C': 'ز', 'V': 'ر', 'B': 'ذ', 'N': 'د', 'M': 'پ', '<': 'و',
+}
+_KEYBOARD_TABLE = str.maketrans(_QWERTY_TO_PERSIAN_MAP)
+
+_ZWNJ = "\u200C"
+
+# Robust prefixes (Noisy ones like "هم" or "هر" are removed to prevent false-positives)
+_PREFIX_PATTERNS = [
+    (re.compile(r"\b(می|نمی)\s+(?=\S)"), r"\1" + _ZWNJ),
+    (re.compile(r"\b(بی)\s+(?=\S)"), r"\1" + _ZWNJ),
+]
+
+# Suffixes including comparative adjectives "تر" and "ترین"
+_SUFFIX_PATTERNS = [
+    (
+        re.compile(r"(?<=\S)\s+(ها|های|هایی|تر|ترین|ای|ام|ات|اش|ایم|اید|اند)\b"),
+        _ZWNJ + r"\1",
+    ),
+]
+
+_ZWNJ_PATTERNS = _PREFIX_PATTERNS + _SUFFIX_PATTERNS
+
+
+def strip_diacritics(text: str) -> str:
+    """Remove Arabic/Persian diacritics (Fatha, Kasra, Damma, Tanween, Tashdeed, Sukuun)."""
+    if not text:
+        return text
+    diacritics_pattern = re.compile(r"[\u064B-\u065F\u0670]")
+    return diacritics_pattern.sub("", text)
+
+
+def is_persian(text: str) -> bool:
+    """Check if the text contains at least one Persian/Arabic script character."""
+    if not text:
+        return False
+    return bool(re.search(r"[\u0600-\u06FF]", text))
+
+
+def correct_keyboard_layout(text: str) -> str:
+    """Correct English layout typed text into Persian layout (e.g. 'sghl' -> 'سلام')."""
+    if not text:
+        return text
+    return text.translate(_KEYBOARD_TABLE)
+
+
+def standardize_persian(text: str, *, strip_diacritics_opt: bool = False) -> str:
+    """Normalize and standardize Persian text layout, character codes, and spaces."""
+    if not text:
+        return text
+
+    if strip_diacritics_opt:
+        text = strip_diacritics(text)
+
+    # Convert characters
+    text = text.translate(_ARABIC_TO_PERSIAN_TABLE)
+
+    # Adjust ZWNJs
+    for pattern, replacement in _ZWNJ_PATTERNS:
+        text = pattern.sub(replacement, text)
+
+    # Collapse redundant spaces
+    text = re.sub(r" {2,}", " ", text).strip()
+
+    return text

parsikit-2.1.0/parsikit/validators.py

@@ -0,0 +1,148 @@
+"""
+parsikit.validators
+~~~~~~~~~~~~~~~~~~~
+Identity, banking, and telephone format validations for Iranian standards.
+"""
+
+import re
+
+_TO_ENGLISH = str.maketrans("۰۱۲۳۴۵۶۷۸۹٠١٢٣٤٥٦٧٨٩", "01234567890123456789")
+
+
+def is_valid_national_code(code: str) -> bool:
+    """Check if the provided code is a valid 10-digit Iranian National Code."""
+    if not code:
+        return False
+
+    clean = "".join(c for c in str(code).translate(_TO_ENGLISH) if c.isdigit())
+
+    if len(clean) != 10:
+        return False
+
+    # Block patterns with repeating single digits (e.g., 1111111111)
+    if len(set(clean)) == 1:
+        return False
+
+    digits = [int(d) for d in clean]
+    check_digit = digits[-1]
+
+    s = sum(digits[i] * (10 - i) for i in range(9))
+    r = s % 11
+
+    if r < 2:
+        return check_digit == r
+    
+    return check_digit == (11 - r)
+
+
+def format_national_code(code: str) -> str:
+    """Format national code into standardized format (e.g. XXX-XXXXXX-X)."""
+    clean = "".join(c for c in str(code).translate(_TO_ENGLISH) if c.isdigit())
+    
+    if len(clean) < 10:
+        clean = clean.zfill(10)
+    elif len(clean) > 10:
+        raise ValueError("National code must not exceed 10 digits.")
+        
+    return f"{clean[:3]}-{clean[3:9]}-{clean[9]}"
+
+
+def is_valid_mobile(phone: str) -> bool:
+    """Validate Iranian mobile numbers (supports +98, 0098, 98, 0 and bare prefixes)."""
+    if not phone:
+        return False
+    clean = "".join(c for c in str(phone).translate(_TO_ENGLISH) if c.isdigit() or c == "+")
+    pattern = re.compile(r"^(?:\+98|0098|98|0)?9\d{9}$")
+    return bool(pattern.match(clean))
+
+
+def normalize_mobile(phone: str, prefix: str = "0") -> str:
+    """Standardize mobile formats to specified layout prefixes (e.g., '0', '+98', '98')."""
+    if not is_valid_mobile(phone):
+        raise ValueError("Invalid Iranian mobile number layout.")
+        
+    clean = "".join(c for c in str(phone).translate(_TO_ENGLISH) if c.isdigit())
+    base = clean[-10:]
+    
+    if prefix == "0":
+        return f"0{base}"
+    elif prefix == "+98":
+        return f"+98{base}"
+    elif prefix == "98":
+        return f"98{base}"
+    
+    raise ValueError("Unsupported prefix format. Choose '0', '+98', or '98'.")
+
+
+def is_valid_card_number(card: str) -> bool:
+    """Validate 16-digit bank card numbers using Luhn checksum algorithm."""
+    if not card:
+        return False
+    clean = "".join(c for c in str(card).translate(_TO_ENGLISH) if c.isdigit())
+    
+    if len(clean) != 16:
+        return False
+        
+    digits = [int(x) for x in clean]
+    for i in range(0, 16, 2):
+        val = digits[i] * 2
+        if val > 9:
+            val -= 9
+        digits[i] = val
+        
+    return sum(digits) % 10 == 0
+
+
+def format_card_number(card: str, separator: str = "-") -> str:
+    """Format bank card numbers into standard four-chunk groups."""
+    clean = "".join(c for c in str(card).translate(_TO_ENGLISH) if c.isdigit())
+    if len(clean) != 16:
+        raise ValueError("Card number must contain exactly 16 digits.")
+    return separator.join([clean[i:i+4] for i in range(0, 16, 4)])
+
+
+def is_valid_sheba(sheba: str) -> bool:
+    """Validate Iranian Sheba (IBAN) format (starts with IR followed by 24 digits)."""
+    if not sheba:
+        return False
+    
+    clean = str(sheba).translate(_TO_ENGLISH).upper().replace(" ", "").replace("-", "")
+
+    if len(clean) == 24 and clean.isdigit():
+        clean = "IR" + clean
+
+    if len(clean) != 26 or not clean.startswith("IR") or not clean[2:].isdigit():
+        return False
+
+    # Move 'IRXX' to end: 'IRXXYYYY...' -> 'YYYY...IRXX'
+    rearranged = clean[4:] + clean[:4]
+    
+    # Translate letters to numbers (I -> 18, R -> 27)
+    num_str = ""
+    for char in rearranged:
+        if char.isalpha():
+            num_str += str(ord(char) - ord('A') + 10)
+        else:
+            num_str += char
+
+    try:
+        return int(num_str) % 97 == 1
+    except ValueError:
+        return False
+
+
+def format_sheba(sheba: str, format_type: str = "spaced") -> str:
+    """Format Sheba values cleanly or into four-character readable blocks."""
+    clean = str(sheba).translate(_TO_ENGLISH).upper().replace(" ", "").replace("-", "")
+
+    if len(clean) == 24 and clean.isdigit():
+        clean = "IR" + clean
+
+    if len(clean) != 26 or not clean.startswith("IR") or not clean[2:].isdigit():
+        raise ValueError("Invalid Sheba structure.")
+
+    if format_type == "clean":
+        return clean
+
+    # spaced chunk format
+    return " ".join([clean[i:i+4] for i in range(0, 26, 4)])

parsikit-2.1.0/parsikit.egg-info/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: parsikit
+Version: 2.1.0
+Summary: A comprehensive and pure Python library for Persian data formatting, validation, and graphical reshaping.
+Author: Ali Kamrani
+Author-email: Ali Kamrani <kamrani.exe@gmail.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: Persian
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: requires-python
+
+# ParsiKit
+
+A lightweight, zero-dependency, pure Python library designed for Persian text standardization, layout reshaping for legacy graphics engines, financial calculations, and Iranian standard format validations.
+
+---
+
+## Key Features
+
+- **Text Normalization & Correction**: Character mapping (Arabic `ي`/`ك` to Persian `ی`/`ک`), robust Zero-Width Non-Joiner (ZWNJ / نیم‌فاصله) formatting for verbs and suffixes, diacritics stripping, and English-to-Persian keyboard layout correction.
+- **Digit & Number Conversions**: Convert digits between English, Persian, and Arabic formats, and translate numbers up to quadrillions into written Persian words.
+- **Currency & Financial Utilities**: Thousand-separator formatting, Rial and Toman conversions, VAT calculator, loan monthly installment calculator, and verbal currency representations.
+- **Iranian Standards Validators**: Real-time validation and clean formatting for National Codes, Mobile Numbers, Bank Cards (with Luhn checksum validation), and Sheba (IBAN) codes.
+- **Graphical Text Reshaper**: A zero-dependency Persian reshaper that connects letters and handles RTL bidirectional flow for rendering text on Left-to-Right graphics engines (such as PIL/Pillow, Unity, Pygame, OpenCV, Matplotlib, or After Effects).
+
+---
+
+## Installation
+
+You can install the package directly from source:
+
+```bash
+git clone https://github.com/MRThugh/ParsiKit.git
+cd ParsiKit
+pip install .
+```
+
+---
+
+## Quick Start & Examples
+
+### 1. Text Normalization & Keyboard Layout Correction
+
+```python
+import parsikit
+
+# Standardize Persian characters and ZWNJ formatting
+raw_text = "ي كافيه ك کتاب ها ميباشد سَلامٌ"
+standardized = parsikit.standardize_persian(raw_text)
+print(standardized)  # "ی کافیه ک کتاب‌ها میباشد سلام"
+
+# Strip diacritics (Harakat)
+clean_text = parsikit.strip_diacritics("سَلامٌ")
+print(clean_text)  # "سلام"
+
+# Correct mistyped English layout text (e.g., typing standard words on wrong layout)
+corrected = parsikit.correct_keyboard_layout("sghl")
+print(corrected)  # "سلام"
+```
+
+### 2. Digit Conversion & Verbal Number Representation
+
+```python
+import parsikit
+
+# Convert digits
+fa_digits = parsikit.english_to_persian("Price: 12500 Toman")
+print(fa_digits)  # "Price: ۱۲۵۰۰ Toman"
+
+# Convert numeric values to written Persian words
+words = parsikit.number_to_words(1453200)
+print(words)  # "یک میلیون و چهارصد و پنجاه و سه هزار و دویست"
+```
+
+### 3. Currency & Loan Installment Planning
+
+```python
+import parsikit
+
+# Format with thousands separators
+formatted = parsikit.format_currency("1500000", currency="toman", persian_digits=True)
+print(formatted)  # "۱،۵۰۰،۰۰۰ تومان"
+
+# Convert currency directly into words
+words = parsikit.format_currency_to_words(1000000, currency="toman")
+print(words)  # "یک میلیون تومان"
+
+# Add Value Added Tax (VAT - Default is 10%)
+total_with_tax = parsikit.add_tax_and_toll(100000)
+print(total_with_tax)  # 110000
+
+# Calculate monthly loan installments (e.g., 10M loan at 18% interest over 12 months)
+monthly_payment = parsikit.calculate_installments(10000000, annual_interest_rate=18.0, months=12)
+print(monthly_payment)  # 916799
+```
+
+### 4. Identity & Banking Validators
+
+```python
+import parsikit
+
+# National Code Checksum Validation & Formatting
+if parsikit.is_valid_national_code("7730123452"):
+    formatted_nc = parsikit.format_national_code("7730123452")
+    print(formatted_nc)  # "773-012345-2"
+
+# Mobile Normalization (Standardizes input with various country code formats)
+if parsikit.is_valid_mobile("+989123456789"):
+    local_mobile = parsikit.normalize_mobile("+989123456789", prefix="0")
+    print(local_mobile)  # "09123456789"
+
+# Luhn Checksum Card Verification
+is_card_valid = parsikit.is_valid_card_number("6037991122334455")
+print(is_card_valid)  # True
+
+# Standard Sheba (IBAN) Checksum Validation & Formatting
+if parsikit.is_valid_sheba("050170000000123456789012"):
+    readable_sheba = parsikit.format_sheba("050170000000123456789012", format_type="spaced")
+    print(readable_sheba)  # "IR05 0170 0000 0012 3456 7890 12"
+```
+
+### 5. Layout Reshaping for Graphical Renderers
+
+```python
+import parsikit
+
+# Forces Left-to-Right layout simulation engines (like PIL/Pillow or Pygame)
+# to render Persian words connected and beautifully aligned.
+graphical_text = parsikit.reshape_for_graphics("سلام Hello جهان", reverse=True)
+print(graphical_text)  # "ﻡﻼﺳ Hello ﻥﺎﻬﺟ"
+```
+
+---
+
+## Running Tests
+
+To verify package integrity, execute the comprehensive test suite locally:
+
+```bash
+python test.py
+```
+
+---
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

parsikit-2.1.0/parsikit.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+setup.py
+parsikit/__init__.py
+parsikit/currency.py
+parsikit/number.py
+parsikit/reshaper.py
+parsikit/text.py
+parsikit/validators.py
+parsikit.egg-info/PKG-INFO
+parsikit.egg-info/SOURCES.txt
+parsikit.egg-info/dependency_links.txt
+parsikit.egg-info/top_level.txt

parsikit-2.1.0/parsikit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

parsikit-2.1.0/parsikit.egg-info/top_level.txt

@@ -0,0 +1 @@
+parsikit

parsikit-2.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "parsikit"
+version = "2.1.0"
+authors = [
+    { name = "Ali Kamrani", email = "kamrani.exe@gmail.com" }
+]
+description = "A comprehensive and pure Python library for Persian data formatting, validation, and graphical reshaping."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Natural Language :: Persian",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["parsikit*"]

parsikit-2.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

parsikit-2.1.0/setup.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+from setuptools import setup, find_packages
+
+README = Path(__file__).parent / "README.md"
+
+setup(
+    name="parsikit",
+    version="0.2.0",
+    author="Ali Kamrani",
+    author_email="kamrani.exe@gmail.com",
+    description="A pure Python library for Persian data formatting.",
+    long_description=README.read_text(encoding="utf-8") if README.exists() else "",
+    long_description_content_type="text/markdown",
+    packages=find_packages(),
+    python_requires=">=3.10",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Natural Language :: Persian",
+        "Intended Audience :: Developers",
+    ],
+)