### Install Dependencies

Source: https://github.com/assyrian-digital-language-consortium/transliterator/blob/main/README.md

Install the project dependencies using pip. Ensure you have Python 3.8+.

```bash
pip install -r requirements.txt
```

--------------------------------

### Run Unit Tests

Source: https://github.com/assyrian-digital-language-consortium/transliterator/blob/main/README.md

Execute the project's unit tests using pytest. Ensure pytest is installed.

```bash
pytest tests
```

--------------------------------

### Run Full Test Suite

Source: https://github.com/assyrian-digital-language-consortium/transliterator/blob/main/README.md

Execute the comprehensive test suite, including linting and refactoring, using the provided shell script.

```bash
./run_tests.sh
```

--------------------------------

### Transliterate Syriac text with default mappings

Source: https://context7.com/assyrian-digital-language-consortium/transliterator/llms.txt

Perform basic transliteration of Syriac text into IPA and romanized forms using the default library settings.

```python
from SyrTransliterator import SyrTransliterator

# Basic usage with default mappings
transliterator = SyrTransliterator()

# Transliterate Syriac text
text = "ܒܨܲܦܪܵܐ ܟܹܐ ܟܵܬ݂ܒ݂ܹܢ ܐܸܓܪ̈ܵܬ݂ܵܐ"
result = transliterator.transliterate(text)

print("IPA:", result["ipa"])
# Output: IPA: bsˤaprɑʔ keʔ kɑθven ʔɪgrɑθɑʔ

print("Natural IPA:", result["natural_ipa"])
# Output: Natural IPA: bsˤaprɑʔ keʔ kɑθven ʔɪgrɑθɑ

print("Romanized:", result["romanized"])
# Output: Romanized: b'ṣapra ke kathwen igratha
```

--------------------------------

### Transliterate with custom IPA mappings

Source: https://context7.com/assyrian-digital-language-consortium/transliterator/llms.txt

Apply both dialect-specific and custom IPA phonetic mappings by providing paths to the respective JSON configuration files.

```python
from SyrTransliterator import SyrTransliterator

# Load both IPA and dialect mappings
transliterator = SyrTransliterator(
    dialect_map_filename='src/dialects/koine.json',
    ipa_mapping_filename='src/ipa/intermediate.json'
)

# Transliterate with custom mappings
text = "ܐܲܒܵܐ"  # "father"
result = transliterator.transliterate(text)

print("IPA:", result["ipa"])
# Output: IPA: ʔabɑʔ

print("Natural IPA:", result["natural_ipa"])
# Output: Natural IPA: abɑ

print("Romanized:", result["romanized"])
# Output: Romanized: aba
```

--------------------------------

### Basic Syriac Transliteration

Source: https://github.com/assyrian-digital-language-consortium/transliterator/blob/main/README.md

Transliterate Syriac text to IPA and romanized forms using default mappings. Instantiate SyrTransliterator and call the transliterate method.

```python
from SyrTransliterator import SyrTransliterator

# Instantiate the transliterator (using default mappings)
transliterator = SyrTransliterator()

text = "ܒܨܲܦܪܵܐ ܟܹܐ ܟܵܬ݂ܒ݂ܹܢ ܐܸܓܪ̈ܵܬ݂ܵܐ"
result = transliterator.transliterate(text)

print("IPA:", result["ipa"])
print("Natural IPA:", result["natural_ipa"])
print("Romanized:", result["romanized"])
```

--------------------------------

### Transliterate with dialect-specific overrides

Source: https://context7.com/assyrian-digital-language-consortium/transliterator/llms.txt

Customize phonetic output by loading a JSON configuration file representing a specific regional dialect.

```python
from SyrTransliterator import SyrTransliterator

# Load Iranian Koine dialect mappings
iranian_koine_file = 'src/dialects/iranian_koine.json'
transliterator = SyrTransliterator(dialect_map_filename=iranian_koine_file)

text = "ܒܨܲܦܪܵܐ ܟܹܐ ܟܵܬ݂ܒ݂ܹܢ ܐܸܓܪ̈ܵܬ݂ܵܐ"
result = transliterator.transliterate(text)

print("IPA:", result["ipa"])
# Output: IPA: bsˤaprɑʔ keʔ kɑθven ʔɪgrɑθɑʔ

print("Natural IPA:", result["natural_ipa"])
# Output: Natural IPA: bsˤaprɑʔ keʔ kɑθven ʔɪgrɑθɑ

print("Romanized:", result["romanized"])
# Output: Romanized: b'ṣapra ke katven igrata
# Note: Different from default - 'th' becomes 't', 'w' becomes 'v'
```

--------------------------------

### Calculate Syriac Character Ratio

Source: https://context7.com/assyrian-digital-language-consortium/transliterator/llms.txt

Employ SyrTools.ratio to compute the proportion of Syriac characters within a given text. This is useful for language identification in mixed-language content.

```python
from SyrTools import SyrTools

tools = SyrTools()

# Pure Syriac text
syriac_only = "ܒܫܸܡܵܐ ܕܐܲܒ݂ܵܐ"
ratio = tools.ratio(syriac_only)
print(f"Syriac ratio: {ratio:.2%}")
# Output: Syriac ratio: 100.00%

# Mixed text
mixed_text = "The word ܫܠܵܡܵܐ means peace"
ratio = tools.ratio(mixed_text)
print(f"Syriac ratio: {ratio:.2%}")
# Output: Syriac ratio: ~20-30% (varies based on whitespace handling)

# Non-Syriac text
english_text = "Hello World"
ratio = tools.ratio(english_text)
print(f"Syriac ratio: {ratio:.2%}")
# Output: Syriac ratio: 0.00%
```

--------------------------------

### Reverse transliterate IPA to Syriac

Source: https://context7.com/assyrian-digital-language-consortium/transliterator/llms.txt

Convert IPA transcriptions back into Syriac script, with support for toggling between Eastern and Western vowel systems.

```python
from SyrTransliterator import SyrTransliterator

transliterator = SyrTransliterator(
    dialect_map_filename='src/dialects/koine.json',
    ipa_mapping_filename='src/ipa/intermediate.json'
)

# Forward transliteration
syriac_text = "ܣܘܼܪ̈ܵܝܹܐ"  # "Syriacs"
result = transliterator.transliterate(syriac_text)
print("IPA:", result["ipa"])
# Output: IPA: surɑjeʔ

# Reverse transliteration (IPA back to Syriac)
reversed_text = transliterator.reverse_transliterate(result["ipa"], eastern=True)
print("Syriac:", reversed_text)
# Output: Syriac: ܣܘܼܪܵܝܹܐ

# Using Western vowel system
reversed_western = transliterator.reverse_transliterate(result["ipa"], eastern=False)
print("Syriac (Western):", reversed_western)
```

--------------------------------

### Detect Syriac Dialect (Eastern/Western)

Source: https://context7.com/assyrian-digital-language-consortium/transliterator/llms.txt

Use SyrTools.eastern and SyrTools.western to determine if Syriac text uses Eastern or Western vowel pointing systems based on diacritics.

```python
from SyrTools import SyrTools

tools = SyrTools()

# Eastern Assyrian text (uses dotted vowels)
eastern_text = "ܐܲܒ݂ܵܐ"  # Uses PTHAHA_DOTTED and ZQAPHA_DOTTED
print(f"Is Eastern: {tools.eastern(eastern_text)}")
# Output: Is Eastern: True
print(f"Is Western: {tools.western(eastern_text)}")
# Output: Is Western: False

# Western Syriac text (uses vowels above/below)
western_text = "ܐܰܒ݂ܳܐ"  # Uses PTHAHA_ABOVE and ZQAPHA_ABOVE
print(f"Is Eastern: {tools.eastern(western_text)}")
# Output: Is Eastern: False
print(f"Is Western: {tools.western(western_text)}")
# Output: Is Western: True
```

--------------------------------

### Dialect JSON Configuration

Source: https://context7.com/assyrian-digital-language-consortium/transliterator/llms.txt

This JSON structure defines dialect-specific romanization mappings, including IPA-to-Roman conversions and special handling for prepositional letters. It allows customization for regional Syriac pronunciation variations.

```json
{
  "dialect": "Iranian Koine",
  "prepositional_b": "o",
  "romanization": {
    "v": "v",
    "ɣ": "gh",
    "ð": "d",
    "x": "kh",
    "f": "f",
    "θ": "t",
    "g": "g",
    "d": "d",
    "k": "k",
    "p": "p",
    "t": "t",
    "ʤ": "j",
    "ʒ": "zh",
    "tʃ": "ch",
    "u": "u",
    "o": "o",
    "i": "i",
    "ʔ": "'",
    "b": "b",
    "h": "h",
    "w": "v",
    "z": "z",
    "ḥ": "kh",
    "tˤ": "ṭ",
    "j": "y",
    "l": "l",
    "m": "m",
    "n": "n",
    "s": "s",
    "ʕ": "ʿ",
    "sˤ": "ṣ",
    "q": "q",
    "r": "r",
    "ʃ": "sh",
    "a": "a",
    "ɑ": "a",
    "ɪ": "i",
    "e": "e"
  }
}
```

--------------------------------

### Transliteration with Dialect Overrides

Source: https://github.com/assyrian-digital-language-consortium/transliterator/blob/main/README.md

Transliterate Syriac text using custom dialect-specific JSON mappings. Provide the path to the dialect JSON file when instantiating SyrTransliterator.

```python
from SyrTransliterator import SyrTransliterator

iranian_koine_file = f'{src_dir}/dialects/iranian_koine.json' # Assuming src_dir is defined elsewhere
transliterator = SyrTransliterator(dialect_map_filename=iranian_koine_file)

text = "ܒܨܲܦܪܵܐ ܟܹܐ ܟܵܬ݂ܒ݂ܹܢ ܐܸܓܪ̈ܵܬ݂ܵܐ"
result = transliterator.transliterate(text)

print("IPA:", result["ipa"])
print("Natural IPA:", result["natural_ipa"])
print("Romanized:", result["romanized"])
```

--------------------------------

### Check for Vowels and Garshuni Characters

Source: https://context7.com/assyrian-digital-language-consortium/transliterator/llms.txt

Utilize SyrTools.contains_vowels to detect vowel diacritics and SyrTools.contains_garshuni to identify Garshuni (Persian/Sogdian) letters in Syriac text.

```python
from SyrTools import SyrTools

tools = SyrTools()

# Text with vowels
vocalized = "ܐܲܒ݂ܵܐ"
print(f"Has vowels: {tools.contains_vowels(vocalized)}")
# Output: Has vowels: True

# Consonantal text (no vowels)
unvocalized = "ܐܒܐ"
print(f"Has vowels: {tools.contains_vowels(unvocalized)}")
# Output: Has vowels: False

# Check for Garshuni characters (Persian/Sogdian letters)
standard_text = "ܫܠܵܡܵܐ"
print(f"Contains Garshuni: {tools.contains_garshuni(standard_text)}")
# Output: Contains Garshuni: False
```

--------------------------------

### Validate Syriac text with SyrTools

Source: https://context7.com/assyrian-digital-language-consortium/transliterator/llms.txt

Check if a string contains valid Syriac characters or verify if a string contains any Syriac content at all.

```python
from SyrTools import SyrTools

tools = SyrTools()

# Check valid Syriac text
syriac_text = "ܒܫܸܡܵܐ ܕܐܲܒ݂ܵܐ"
is_valid = tools.isSyr(syriac_text)
print(f"'{syriac_text}' is Syriac: {is_valid}")
# Output: 'ܒܫܸܡܵܐ ܕܐܲܒ݂ܵܐ' is Syriac: True

# Check mixed text
mixed_text = "Hello 1234567890"
is_valid = tools.isSyr(mixed_text)
print(f"'{mixed_text}' is Syriac: {is_valid}")
# Output: 'Hello 1234567890' is Syriac: False

# Check if text contains any Syriac characters
contains_syr = tools.containsSyr(mixed_text)
print(f"Contains Syriac: {contains_syr}")
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.