japanese-verb-conjugator-v2 0.3.1

Fork of the project https://github.com/jshiohaha/JapaneseVerbConjugator

Japanese Verb Conjugator

Japanese Verb Conjugator is a Python library for conjugating Japanese verbs. This fork is used to fix some Issues in the usage of the base package. Changes will be recorded in CHANGELOG.md

What forms will Japanese Verb Conjugator conjugate?

Japanese Verb Conjugator conjugates the following verb forms:

• plain form
• polite form
• ~te form
• conditional form
• volitional form
• potential form
• imperative form
• provisional form
• causative form
• passive form

Japanese Verb Conjugator conjugates verbs based on verb class, tense, formality, and polarity parameters. Depending on the conjugation and verb class, the parameters for conjugation methods may vary.

Example

generate_plain_form requires verb class, tense, and formality parameters.

generate_volitional_form requires verb class, tense, and polarity parameters.

Similarily the conjugations of the copula だ/です can be generated.

Installation

Use the package manager pip to install japanese-verb-conjugator-v2. If you want to install japanese-verb-conjugator-v2 and its dependencies in a virtual environment, first create and activiate a virtual environment. If you want to change the virtual environment name to someting other than venv, replace the second venv with your desired name. Use that same name to replace venv in the second command.

python3 -m venv venv
source venv/bin/activate

If you run into trouble, see the Python Virtual Environment tutorial.

Method 1: Pypi

After installing and activating the virtual environment, run the following commands to install japanese-verb-conjugator-v2 and its dependencies.

pip install japanese-verb-conjugator-v2

Note

Pip may display an error during installation that includes the following message.

No matching distribution found for romkan (from JapaneseVerbConjugator)

In this case, run the command pip install romkan and then run pip install japanese-verb-conjugator-v2 again.

You should be good to go! See the Usage section on how to get started using the library.

Method 2: Clone this repository

Go to the directory you want to clone this repository and run the following command.

git clone https://github.com/Bel-Shazzar/JapaneseVerbConjugator.git

To install the Library use the following command

pip install .

To run the library you should install the dependencies in requirements.txt.

pip install -r requirements.txt

You should be good to go! See the Usage section on how to get started using the library.

Usage

The easiest to use method is the following:

from japverbconj.constants.enumerated_types import VerbClass
from japverbconj.verb_form_gen import generate_japanese_verb_by_str

generate_japanese_verb_by_str("飲む", VerbClass.GODAN, "pla") # returns '飲む
generate_japanese_verb_by_str("飲む", VerbClass.GODAN, "pla", "past", "neg") # returns '飲まなかった'
generate_japanese_verb_by_str("飲む", VerbClass.GODAN, "pass", "pol", "neg") # returns '飲まれません'

The strings after the VerbClass are built like this:

The first string is required and must determine the desired BaseForm from the following.

BaseForm.PLAIN = "pla"
BaseForm.POLITE = "pol"
BaseForm.TE = "te"
BaseForm.CONDITIONAL = "cond"
BaseForm.VOLITIONAL = "vol"
BaseForm.POTENTIAL = "pot"
BaseForm.IMPERATIVE = "imp"
BaseForm.PROVISIONAL = "prov"
BaseForm.CAUSATIVE = "caus"
BaseForm.PASSIVE = "pass"

The following arguments determine the specific conjugation, based on Formality, Tense and Polarity.

Formality.PLAIN = "pla"
Formality.POLITE = "pol"

Tense.NONPAST = "nonpast"
Tense.PAST = "past"

Polarity.POSITIVE = "pos"
Polarity.NEGATIVE = "neg"

• if an argument is left out, the first choice in the list above is assumed
• the order of the arguments do not matter
• it is not possible to give arguments that are not present in the corresponding BaseForm, see following table for details

BaseForm	Possible arguments
BaseForm.PLAIN BaseForm.POLITE	Tense, Polarity
BaseForm.TE* BaseForm.CONDITIONAL BaseForm.VOLITIONAL BaseForm.POTENTIAL BaseForm.IMPERATIVE BaseForm.PROVISIONAL BaseForm.CAUSATIVE BaseForm.PASSIVE	Formality, Polarity

* except for Formality.POLITE + Polarity.NEGATIVE - if you know whether and if yes, how this form is built, please contact me!

If you prefer the more rigorous earlier version of calling individual methods for each form, you can still use that like this.

from japverbconj.constants.enumerated_types import Formality, Polarity, Tense, VerbClass
from japverbconj.verb_form_gen import JapaneseVerbFormGenerator as jvfg

jvfg.generate_plain_form("飲む", VerbClass.GODAN, Tense.NONPAST, Polarity.POSITIVE) # returns '飲む'
jvfg.generate_plain_form("飲む", VerbClass.GODAN, Tense.NONPAST, Polarity.NEGATIVE) # returns '飲まない'

The library will try to help validate the correctness of the verb by checking for invalid verb lengths, non-Japanese characters, and invalid verb endings. Limitation: this library cannot identify Chinese words with valid Japanese particle endings or nonexistent Japanese verbs.

Copula

Generation of copula forms works similarly:

from japverbconj.verb_form_gen import generate_japanese_copula_by_str

generate_japanese_copula_by_str("plain") # returns 'だ'
generate_japanese_copula_by_str("pres", "pol", "neg") # returns 'ではないでしょう'

The first argument is required and has to be one of the strings:

CopulaForm.PLAIN = "pla"
CopulaForm.POLITE = "pol"
CopulaForm.TE = "te"
CopulaForm.CONDITIONAL = "cond"
CopulaForm.TARA = "tara"
CopulaForm.PRESUMPTIVE = "pres"

The following strings can be of the corresponding arguments

CopulaForm	Possible arguments
CopulaForm.PLAIN CopulaForm.POLITE	Tense, Polarity
CopulaForm.TE CopulaForm.TARA	Formality
CopulaForm.CONDITIONAL
CopulaForm.PRESUMPTIVE	Formality, Polarity

The original way of calling individual methods also remains.

from japverbconj.constants.enumerated_types import Formality, Polarity, Tense, VerbClass
from japverbconj.verb_form_gen import JapaneseVerbFormGenerator as jvfg

jvfg.copula.generate_plain_form(Tense.NONPAST, Polarity.POSITIVE) # returns 'だ'
jvfg.copula.generate_presumptive_form(Formality.POLITE, Polarity.NEGATIVE) # returns 'ではないでしょう'

Tests

The coverage package is used to run the unittests. The configuration is defined in .coveragerc To run the tests, first install the testing requirements

pip install -r test/requirements.txt

Run tests

You can run the tests like this

coverage run -m unittest

View coverage report

After running the tests with coverage you can show the coverage report like this

coverage report

Alternativly you can generate an html representation like this

coverage html

You can open the html in a browser like this

open htmlcov/index.html

Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

License

This project uses a Python package named romkan, which has a BSD license. This project therefore has a BSD license.