Generating words with vidyut.prakriya

vidyut.prakriya generates Sanskrit words with their prakriyās (derivations) according to the rules of Paninian grammar. This powerful word generator is useful both for creating Sanskrit words and for understanding how words are derived.

Note

All inputs to vidyut.prakriya should use the SLP1 encoding scheme, and output is likewise encoded in SLP1. You can convert to and from SLP1 by using vidyut.lipi or your favorite transliterator.

Sanskrit grammatical terms

vidyut.prakriya closely follows the rules of the Aṣṭādhyāyī, the core text of the Sanskrit grammatical tradition. Here are the most important terms to know:

Sanskrit terms with English equivalents
Sanskrit	English
aupadeśika	the “instructional” or technical form of some term
antargaṇa	verb subclass
avyaya	uninflected word
upasarga	verb prefix
kṛt	verb suffix
gaṇa	verb class
taddhita	nominal suffix
tiṅanta	verb
dhātu	verb root
pada	word
puruṣa	person
prayoga	voice
prakriyā	derivation (of a word)
prātipadika	nominal stem
lakāra	tense-mood
liṅga	gender
vacana	number
vibhakti	case
sanādi	derived root suffix
samāsa	compound
subanta	nominal

Quickstart

All usage of vidyut.prakriya follows a basic flow:

We create a new Vyakarana object, which is our main interface to the grammar. When we create Vyakarana, we can also fine-tune the rules and settings the system will use. Creating this object is fast and lightweight.
We pass various arguments to Vyakarana to define our derivation.
We receive a list of Prakriya objects. Each Prakriya contains a final result and the rules that produced it.

To illustrate, let’s derive the simple verb Bavati:

from vidyut.prakriya import (
    Vyakarana,
    Dhatu,
    Gana,
    Pada,
    Prayoga,
    Purusha,
    Vacana,
    Lakara
)

# 1. Create a new `Vyakarana` object.
v = Vyakarana()

# 2. Define and run our derivation.
prakriyas = v.derive(Pada.Tinanta(
    # `aupadeshika` should includes svaras as necessary. If you don't
    # want to add this yourself, see "Working with data files" below.
    dhatu=Dhatu.mula(aupadeshika="BU", gana=Gana.Bhvadi),
    prayoga=Prayoga.Kartari,
    lakara=Lakara.Lat,
    purusha=Purusha.Prathama,
    vacana=Vacana.Eka,
))

# 3. Receive a list of prakriyas.
for prakriya in prakriyas:
    print(prakriya.text)
    print('===================')
    for step in prakriya.history:
        result = ' + '.join(term.text for term in step.result)
        print("{:<10}: {}".format(step.code, result))

This produces the following output:

Bavati
===================
3.1     : BU
2.123   : BU + la~w
3.2     : BU + la~w
3.3     : BU + la~w
3.9     : BU + l
3.78    : BU + l
4.78    : BU + tip
3.3     : BU + tip
3.9     : BU + ti
4.113   : BU + ti
1.68    : BU + Sap + ti
3.3     : BU + Sap + ti
3.8     : BU + Sap + ti
3.9     : BU + a + ti
4.113   : BU + a + ti
4.13    : BU + a + ti
3.84    : Bo + a + ti
4.14    : Bo + a + ti
1.78    : Bav + a + ti
4.68    : Bav + a + ti

Basic methods

Vyakarana.derive() is the main method for creating derivations. It accepts several kinds of input arguments and returns a list of Prakriya objects according to the the arguments provided.

To derive tinantas, use Pada.Tinanta():

from vidyut.prakriya import *

v = Vyakarana()
bhu = Dhatu.mula(aupadeshika="BU", gana=Gana.Bhvadi)
prakriyas = v.derive(Pada.Tinanta(
    dhatu=bhu,
    prayoga=Prayoga.Kartari,
    lakara=Lakara.Lat,
    purusha=Purusha.Prathama,
    vacana=Vacana.Eka,
))

assert len(prakriyas) == 1
assert prakriyas[0].text == "Bavati"

To derive subantas, use Pada.Subanta():

deva = Pratipadika.basic("deva")
prakriyas = v.derive(Pada.Subanta(
    pratipadika=deva,
    linga=Linga.Pum,
    vibhakti=Vibhakti.Prathama,
    vacana=Vacana.Eka,
))

assert len(prakriyas) == 1
assert prakriyas[0].text == "devaH"

To derive pratipadikas, use Pratipadika:

v = Vyakarana()

# Krdanta
# NOTE: all values on `Krt` are written in SLP1. See the API docs for a
# full list of supported values.
abhibhu = Dhatu.mula(aupadeshika="BU", gana=Gana.Bhvadi).with_prefixes(["aBi"])
abhibhavaka = Pratipadika.krdanta(abhibhu, Krt.Rvul)
prakriyas = v.derive(abhibhavaka)
assert prakriyas[0].text == "aBiBAvaka"

# Taddhitanta
# NOTE: all values on `Taddhita` are written in SLP1. See the API docs for a
# full list of supported values.
guru = Pratipadika.basic("guru")
gaurava = Pratipadika.taddhitanta(guru, Taddhita.aR)
prakriyas = v.derive(gaurava)
assert prakriyas[0].text == "gOrava"

To derive dhatus, use Dhatu:

v = Vyakarana()

upa_r = Dhatu.mula(aupadeshika="f\\", gana=Gana.Bhvadi).with_prefixes(["upa"])
prakriyas = v.derive(upa_r)

assert len(prakriyas) == 1
assert prakriyas[0].text == "upAr"

Specifying arguments

The real expressive power in this library comes from expressing different kinds of arguments.

For example, we can modify a Dhatu to use one or more prefixes:

bhu = Dhatu.mula("BU", Gana.Bhvadi)
abhibhu = Dhatu.mula("BU", Gana.Bhvadi, prefixes=["abhi"])

# Or, use the shorthand method `with_prefixes`:
paribhu = bhu.with_prefixes(["abhi"])

Or one or more Sanadi suffixes:

bhu = Dhatu.mula("BU", Gana.Bhvadi)
bhavaya = Dhatu.mula("BU", Gana.Bhvadi, sanadi=[Sanadi.Ric])

# Or, use the shorthand method `with_sanadi`.
bubhusha = bhu.with_sanadi([Sanadi.san])

# These can be combined with prefixes.
abhibubhusha = bhu.with_prefixes(["aBi"]).with_sanadi([Sanadi.san])

These dhatus can be used to create more complex forms:

prakriyas = v.derive(Pada.Tinanta(
    dhatu=abhibubhusha,
    prayoga=Prayoga.Kartari,
    lakara=Lakara.Lat,
    purusha=Purusha.Prathama,
    vacana=Vacana.Eka,
))
assert prakriyas[0].text == 'aBibuBUzati'

Likewise, we can declare that a Pratipadika is a krdanta:

bhu = Dhatu.mula(aupadeshika="BU", gana=Gana.Bhvadi)
bhavat = Pratipadika.krdanta(bhu, Krt.Satf)

Or a taddhitanta:

guru = Pratipadika.basic("guru")
gaurava = Pratipadika.taddhitanta(guru, Taddhita.aR)

These pratipadikas can likewise be used to create more complex forms:

prakriyas = v.derive(Pada.Subanta(
    pratipadika=bhavat,
    linga=Linga.Pum,
    vibhakti=Vibhakti.Prathama,
    vacana=Vacana.Dvi,
))
assert prakriyas[0].text == 'BavantO'

Working with data files

vidyut.prakriya is more interesting when used with the side data provided in Vidyut’s official data download. We expose this data through the Data object, whose main methods are load_dhatu_entries() and load_sutras().

load_dhatu_entries() loads all dhatus from the Dhatupatha along with their meanings:

from vidyut.prakriya import *

data = Data("/path/to/dhatupatha.tsv")
dhatus = [e.dhatu for e in data.load_dhatu_entries()]

v = Vyakarana(log_steps=False)
for dhatu in dhatus:
    prakriyas = v.derive(Pada.Subanta(
        dhatu=dhatu,
        prayoga=Prayoga.Kartari,
        lakara=Lakara.Lat,
        purusha=Purusha.Prathama,
        vacana=Vacana.Eka,
    ))
    for prakriya in prakriyas:
        print(prakriya.text)

The Dhatupatha we provide is essentially identical to the one used on ashtadhyayi.com.

load_sutras(), meanwhile, loads all sutras used as part of a derivation:

sutras = data.load_sutras()
ashtadhyayi = [s for s in sutras if s.source == Source.Ashtadhyayi]

assert ashtadhyayi[0].source == Source.Ashtadhyayi
assert ashtadhyayi[0].code == "1.1.1"
assert ashtadhyayi[0].text == "vfdDirAdEc"

load_sutras() includes data from the Ashtadhyayi, the Unadipatha, ganasutras from the Dhatupatha, various vārttikas, and other smaller sources.

Recipes

This section contains various recipes that show how to use vidyut.prakriya for different tasks.

Generate a single prakriya with its sutras

from vidyut.prakriya import *

data = Data("/path/to/prakriya/data")
code_to_sutra = {(s.source, s.code): s.text for s in data.load_sutras()}

v = Vyakarana()
prakriyas = v.derive(Pada.Tinanta(
    dhatu=Dhatu.mula(aupadeshika="BU", gana=Gana.Bhvadi),
    prayoga=Prayoga.Kartari,
    lakara=Lakara.Lat,
    purusha=Purusha.Prathama,
    vacana=Vacana.Eka,
))

for prakriya in prakriyas:
    print(prakriya.text)
    print('===================')
    for step in prakriya.history:
        result = ' + '.join(step.result)
        key = (step.source, step.code)

        # WARNING: use `get` to avoid a KeyError. While 99.9% of sutras are defined in
        # `code_to_sutras`, there might still be some sutras we have missed.
        sutra = code_to_sutra.get(key, "(missing)")
        print("{:<10}: {:<15} {}".format(step.code, result, sutra))

Output:

Bavati
===================
3.1     : BU              BUvAdayo DAtavaH
2.123   : BU + la~w       vartamAne law
3.2     : BU + la~w       upadeSe'janunAsika it
3.3     : BU + la~w       halantyam
3.9     : BU + l          tasya lopaH
3.78    : BU + l          SezAt kartari parasmEpadam
4.78    : BU + tip        tiptasJisipTasTamibvasmas tAtAMJaTAsATAMDvamiqvahimahiN
3.3     : BU + tip        halantyam
3.9     : BU + ti         tasya lopaH
4.113   : BU + ti         tiNSitsArvaDAtukam
1.68    : BU + Sap + ti   kartari Sap
3.3     : BU + Sap + ti   halantyam
3.8     : BU + Sap + ti   laSakvatadDite
3.9     : BU + a + ti     tasya lopaH
4.113   : BU + a + ti     tiNSitsArvaDAtukam
4.13    : BU + a + ti     yasmAt pratyayaviDistadAdi pratyaye'Ngam
3.84    : Bo + a + ti     sArvaDAtukArDaDAtukayoH
4.14    : Bo + a + ti     suptiNantaM padam
1.78    : Bav + a + ti    eco'yavAyAvaH
4.68    : Bav + a + ti    a a

Generate all tinantas for some dhatu and prayoga

from vidyut.prakriya import *

v = Vyakarana(log_steps=False)
bhu = Dhatu.mula("BU", Gana.Bhvadi)

for lakara in Lakara.choices():
    for purusha in Purusha.choices():
        for vacana in Vacana.choices():
            prakriyas = v.derive(Pada.Tinanta(
                dhatu=bhu,
                prayoga=Prayoga.Kartari,
                lakara=lakara,
                purusha=purusha,
                vacana=vacana,
            ))
            for p in prakriyas:
                print(p.text)

Generate tinantas from the Dhatupatha

from vidyut.prakriya import *

data = Data("/path/to/prakriya")
dhatus = [e.dhatu for e in data.load_dhatu_entries()]

v = Vyakarana(log_steps=False)

prayoga = Prayoga.Kartari
for dhatu in dhatus:
    for lakara in Lakara.choices():
        for purusha in Purusha.choices():
            for vacana in Vacana.choices():
                prakriyas = v.derive(Pada.Tinanta(
                    dhatu=dhatu,
                    prayoga=prayoga,
                    lakara=lakara,
                    purusha=purusha,
                    vacana=vacana,
                ))
                for p in prakriyas:
                    print(p.text)

Generate all subantas for some pratipadika

from vidyut.prakriya import *

v = Vyakarana(log_steps=False)
nara = Pratipadika.basic("nara")

for vibhakti in Vibhakti.choices():
    for vacana in Vacana.choices():
        prakriyas = v.derive(Pada.Subanta(
            pratipadika=nara,
            linga=Linga.Pum,
            vibhakti=vibhakti,
            vacana=vacana,
        ))
        for p in prakriyas:
            print(vibhakti, vacana, p.text)

Generate all krdantas for some dhatu

from vidyut.prakriya import *

v = Vyakarana()
bhu = Dhatu.mula("BU", Gana.Bhvadi)

for krt in Krt.choices():
    anga = Pratipadika.krdanta(bhu, krt)
    prakriyas = v.derive(anga)
    for p in prakriyas:
        print(krt, p.text)
    else:
        print(f"- (no results for BU + {krt})")

Generate all taddhitantas for some pratipadika

from vidyut.prakriya import *

v = Vyakarana()
guru = Pratipadika.basic("guru")

for taddhita in Taddhita.choices():
    anga = Pratipadika.taddhitanta(guru, taddhita)
    prakriyas = v.derive(anga)
    for p in prakriyas:
        print(taddhita, p.text)
    else:
        print(f"- (no results for guru + {taddhita})")

Find all rules used by a dhatu’s tinantas

from vidyut.prakriya import *

v = Vyakarana()
bhu = Dhatu.mula("BU", Gana.Bhvadi)

rules = set()
for prayoga in Prayoga.choices():
    for lakara in Lakara.choices():
        for purusha in Purusha.choices():
            for vacana in Vacana.choices():
                prakriyas = v.derive(Pada.Tinanta(
                    dhatu=bhu,
                    prayoga=prayoga,
                    lakara=lakara,
                    purusha=purusha,
                    vacana=vacana,
                ))
                for p in prakriyas:
                    for step in p.history:
                        rules.add(step.code)