ru-api-free 1.0.0__py3-none-any.whl

ru_api_free/__init__.py

@@ -0,0 +1,9 @@
+from .conjugator import conjugate, search_verbs, list_verbs, get_exceptions, get_verb_exceptions, EXCEPTION_TYPES
+from .dictionary import translate_en_to_ru
+
+__version__ = "1.0.0"
+__all__ = [
+    "conjugate", "search_verbs", "list_verbs",
+    "get_exceptions", "get_verb_exceptions", "EXCEPTION_TYPES",
+    "translate_en_to_ru",
+]

ru_api_free/__main__.py

@@ -0,0 +1,10 @@
+import uvicorn
+from .main import app
+
+
+def main():
+    uvicorn.run("ru_api_free.main:app", host="0.0.0.0", port=8000, reload=False)
+
+
+if __name__ == "__main__":
+    main()

ru_api_free/conjugator.py

@@ -0,0 +1,758 @@
+# Russian Verb Conjugator API
+
+PERSONS = ["я", "ты", "он/она/оно", "мы", "вы", "они"]
+SIBILANTS = set("жшчщ")
+
+IRR = {}
+
+EXCEPTION_TYPES = {
+    "irregular": "Full conjugation is irregular (does not follow standard patterns)",
+    "conj_class": "2nd conjugation despite having a 1st-conjugation ending (-еть/-ать)",
+    "mut_1sg": "Consonant mutation in 1st person singular",
+    "stem_change": "Stem changes in present/future tense (-овать, -ва-, consonant-j, etc.)",
+    "sibilant_stem": "Sibilant/fricative stem alternation in present/future",
+    "past_irreg": "Irregular past tense form",
+    "nut_verb": "-нуть verb (perfective with special stem)",
+    "reflexive": "Reflexive verb (-ся)",
+}
+
+EXCEPTIONS = {}
+
+def ir(verb, present, past, future=None):
+    IRR[verb] = {"present": present, "past": past, "future": future}
+
+# --- All irregular/conjugation-table verbs ---
+ir("быть",
+   {"я": "есть", "ты": "есть", "он/она/оно": "есть", "мы": "есть", "вы": "есть", "они": "есть"},
+   {"мужской": "был", "женский": "была", "средний": "было", "множественное": "были"},
+   {"я": "буду", "ты": "будешь", "он/она/оно": "будет", "мы": "будем", "вы": "будете", "они": "будут"})
+
+ir("дать", None,
+   {"мужской": "дал", "женский": "дала", "средний": "дало", "множественное": "дали"},
+   {"я": "дам", "ты": "дашь", "он/она/оно": "даст", "мы": "дадим", "вы": "дадите", "они": "дадут"})
+
+ir("есть",
+   {"я": "ем", "ты": "ешь", "он/она/оно": "ест", "мы": "едим", "вы": "едите", "они": "едят"},
+   {"мужской": "ел", "женский": "ела", "средний": "ело", "множественное": "ели"})
+
+ir("хотеть",
+   {"я": "хочу", "ты": "хочешь", "он/она/оно": "хочет", "мы": "хотим", "вы": "хотите", "они": "хотят"},
+   {"мужской": "хотел", "женский": "хотела", "средний": "хотело", "множественное": "хотели"})
+
+ir("ехать",
+   {"я": "еду", "ты": "едешь", "он/она/оно": "едет", "мы": "едем", "вы": "едете", "они": "едут"},
+   {"мужской": "ехал", "женский": "ехала", "средний": "ехало", "множественное": "ехали"})
+
+ir("ошибиться", None,
+   {"мужской": "ошибся", "женский": "ошиблась", "средний": "ошиблось", "множественное": "ошиблись"},
+   {"я": "ошибусь", "ты": "ошибёшься", "он/она/оно": "ошибётся", "мы": "ошибёмся", "вы": "ошибётесь", "они": "ошибутся"})
+
+ir("взять", None,
+   {"мужской": "взял", "женский": "взяла", "средний": "взяло", "множественное": "взяли"},
+   {"я": "возьму", "ты": "возьмёшь", "он/она/оно": "возьмёт", "мы": "возьмём", "вы": "возьмёте", "они": "возьмут"})
+
+ir("понять", None,
+   {"мужской": "понял", "женский": "поняла", "средний": "поняло", "множественное": "поняли"},
+   {"я": "пойму", "ты": "поймёшь", "он/она/оно": "поймёт", "мы": "поймём", "вы": "поймёте", "они": "поймут"})
+
+ir("начать", None,
+   {"мужской": "начал", "женский": "начала", "средний": "начало", "множественное": "начали"},
+   {"я": "начну", "ты": "начнёшь", "он/она/оно": "начнёт", "мы": "начнём", "вы": "начнёте", "они": "начнут"})
+
+ir("бежать",
+   {"я": "бегу", "ты": "бежишь", "он/она/оно": "бежит", "мы": "бежим", "вы": "бежите", "они": "бегут"},
+   {"мужской": "бежал", "женский": "бежала", "средний": "бежало", "множественное": "бежали"})
+
+# -ти verbs
+ir("идти",
+   {"я": "иду", "ты": "идёшь", "он/она/оно": "идёт", "мы": "идём", "вы": "идёте", "они": "идут"},
+   {"мужской": "шёл", "женский": "шла", "средний": "шло", "множественное": "шли"})
+
+ir("прийти", None,
+   {"мужской": "пришёл", "женский": "пришла", "средний": "пришло", "множественное": "пришли"},
+   {"я": "приду", "ты": "придёшь", "он/она/оно": "придёт", "мы": "придём", "вы": "придёте", "они": "придут"})
+
+ir("пройти", None,
+   {"мужской": "прошёл", "женский": "прошла", "средний": "прошло", "множественное": "прошли"},
+   {"я": "пройду", "ты": "пройдёшь", "он/она/оно": "пройдёт", "мы": "пройдём", "вы": "пройдёте", "они": "пройдут"})
+
+ir("найти", None,
+   {"мужской": "нашёл", "женский": "нашла", "средний": "нашло", "множественное": "нашли"},
+   {"я": "найду", "ты": "найдёшь", "он/она/оно": "найдёт", "мы": "найдём", "вы": "найдёте", "они": "найдут"})
+
+ir("нести",
+   {"я": "несу", "ты": "несёшь", "он/она/оно": "несёт", "мы": "несём", "вы": "несёте", "они": "несут"},
+   {"мужской": "нёс", "женский": "несла", "средний": "несло", "множественное": "несли"})
+
+ir("везти",
+   {"я": "везу", "ты": "везёшь", "он/она/оно": "везёт", "мы": "везём", "вы": "везёте", "они": "везут"},
+   {"мужской": "вёз", "женский": "везла", "средний": "везло", "множественное": "везли"})
+
+ir("вести",
+   {"я": "веду", "ты": "ведёшь", "он/она/оно": "ведёт", "мы": "ведём", "вы": "ведёте", "они": "ведут"},
+   {"мужской": "вёл", "женский": "вела", "средний": "вело", "множественное": "вели"})
+
+ir("ползти",
+   {"я": "ползу", "ты": "ползёшь", "он/она/оно": "ползёт", "мы": "ползём", "вы": "ползёте", "они": "ползут"},
+   {"мужской": "полз", "женский": "ползла", "средний": "ползло", "множественное": "ползли"})
+
+ir("расти",
+   {"я": "расту", "ты": "растёшь", "он/она/оно": "растёт", "мы": "растём", "вы": "растёте", "они": "растут"},
+   {"мужской": "рос", "женский": "росла", "средний": "росло", "множественное": "росли"})
+
+ir("цвести",
+   {"я": "цвету", "ты": "цветёшь", "он/она/оно": "цветёт", "мы": "цветём", "вы": "цветёте", "они": "цветут"},
+   {"мужской": "цвёл", "женский": "цвела", "средний": "цвело", "множественное": "цвели"})
+
+ir("класть",
+   {"я": "кладу", "ты": "кладёшь", "он/она/оно": "кладёт", "мы": "кладём", "вы": "кладёте", "они": "кладут"},
+   {"мужской": "клал", "женский": "клала", "средний": "клало", "множественное": "клали"})
+
+ir("лезть",
+   {"я": "лезу", "ты": "лезешь", "он/она/оно": "лезет", "мы": "лезем", "вы": "лезете", "они": "лезут"},
+   {"мужской": "лез", "женский": "лезла", "средний": "лезло", "множественное": "лезли"})
+
+# -чь verbs
+ir("мочь",
+   {"я": "могу", "ты": "можешь", "он/она/оно": "может", "мы": "можем", "вы": "можете", "они": "могут"},
+   {"мужской": "мог", "женский": "могла", "средний": "могло", "множественное": "могли"})
+
+ir("помочь", None,
+   {"мужской": "помог", "женский": "помогла", "средний": "помогло", "множественное": "помогли"},
+   {"я": "помогу", "ты": "поможешь", "он/она/оно": "поможет", "мы": "поможем", "вы": "поможете", "они": "помогут"})
+
+ir("беречь",
+   {"я": "берегу", "ты": "бережёшь", "он/она/оно": "бережёт", "мы": "бережём", "вы": "бережёте", "они": "берегут"},
+   {"мужской": "берёг", "женский": "берегла", "средний": "берегло", "множественное": "берегли"})
+
+ir("печь",
+   {"я": "пеку", "ты": "печёшь", "он/она/оно": "печёт", "мы": "печём", "вы": "печёте", "они": "пекут"},
+   {"мужской": "пёк", "женский": "пекла", "средний": "пекло", "множественное": "пекли"})
+
+ir("течь",
+   {"я": "теку", "ты": "течёшь", "он/она/оно": "течёт", "мы": "течём", "вы": "течёте", "они": "текут"},
+   {"мужской": "тёк", "женский": "текла", "средний": "текло", "множественное": "текли"})
+
+ir("сечь",
+   {"я": "секу", "ты": "сечёшь", "он/она/оно": "сечёт", "мы": "сечём", "вы": "сечёте", "они": "секут"},
+   {"мужской": "сёк", "женский": "секла", "средний": "секло", "множественное": "секли"})
+
+ir("жечь",
+   {"я": "жгу", "ты": "жжёшь", "он/она/оно": "жжёт", "мы": "жжём", "вы": "жжёте", "они": "жгут"},
+   {"мужской": "жёг", "женский": "жгла", "средний": "жгло", "множественное": "жгли"})
+
+ir("стричь",
+   {"я": "стригу", "ты": "стрижёшь", "он/она/оно": "стрижёт", "мы": "стрижём", "вы": "стрижёте", "они": "стригут"},
+   {"мужской": "стриг", "женский": "стригла", "средний": "стригло", "множественное": "стригли"})
+
+ir("влечь",
+   {"я": "влеку", "ты": "влечёшь", "он/она/оно": "влечёт", "мы": "влечём", "вы": "влечёте", "они": "влекут"},
+   {"мужской": "влёк", "женский": "влекла", "средний": "влекло", "множественное": "влекли"})
+
+# Consonant-j-stem verbs (бить, пить, etc.)
+ir("бить",
+   {"я": "бью", "ты": "бьёшь", "он/она/оно": "бьёт", "мы": "бьём", "вы": "бьёте", "они": "бьют"},
+   {"мужской": "бил", "женский": "била", "средний": "било", "множественное": "били"})
+
+ir("пить",
+   {"я": "пью", "ты": "пьёшь", "он/она/оно": "пьёт", "мы": "пьём", "вы": "пьёте", "они": "пьют"},
+   {"мужской": "пил", "женский": "пила", "средний": "пило", "множественное": "пили"})
+
+ir("лить",
+   {"я": "лью", "ты": "льёшь", "он/она/оно": "льёт", "мы": "льём", "вы": "льёте", "они": "льют"},
+   {"мужской": "лил", "женский": "лила", "средний": "лило", "множественное": "лили"})
+
+ir("шить",
+   {"я": "шью", "ты": "шьёшь", "он/она/оно": "шьёт", "мы": "шьём", "вы": "шьёте", "они": "шьют"},
+   {"мужской": "шил", "женский": "шила", "средний": "шило", "множественное": "шили"})
+
+ir("вить",
+   {"я": "вью", "ты": "вьёшь", "он/она/оно": "вьёт", "мы": "вьём", "вы": "вьёте", "они": "вьют"},
+   {"мужской": "вил", "женский": "вила", "средний": "вило", "множественное": "вили"})
+
+ir("брить",
+   {"я": "брею", "ты": "бреешь", "он/она/оно": "бреет", "мы": "бреем", "вы": "бреете", "они": "бреют"},
+   {"мужской": "брил", "женский": "брила", "средний": "брило", "множественное": "брили"})
+
+ir("жить",
+   {"я": "живу", "ты": "живёшь", "он/она/оно": "живёт", "мы": "живём", "вы": "живёте", "они": "живут"},
+   {"мужской": "жил", "женский": "жила", "средний": "жило", "множественное": "жили"})
+
+ir("плыть",
+   {"я": "плыву", "ты": "плывёшь", "он/она/оно": "плывёт", "мы": "плывём", "вы": "плывёте", "они": "плывут"},
+   {"мужской": "плыл", "женский": "плыла", "средний": "плыло", "множественное": "плыли"})
+
+ir("слыть",
+   {"я": "слыву", "ты": "слывёшь", "он/она/оно": "слывёт", "мы": "слывём", "вы": "слывёте", "они": "слывут"},
+   {"мужской": "слыл", "женский": "слыла", "средний": "слыло", "множественное": "слыли"})
+
+ir("петь",
+   {"я": "пою", "ты": "поёшь", "он/она/оно": "поёт", "мы": "поём", "вы": "поёте", "они": "поют"},
+   {"мужской": "пел", "женский": "пела", "средний": "пело", "множественное": "пели"})
+
+ir("брать",
+   {"я": "беру", "ты": "берёшь", "он/она/оно": "берёт", "мы": "берём", "вы": "берёте", "они": "берут"},
+   {"мужской": "брал", "женский": "брала", "средний": "брало", "множественное": "брали"})
+
+ir("ждать",
+   {"я": "жду", "ты": "ждёшь", "он/она/оно": "ждёт", "мы": "ждём", "вы": "ждёте", "они": "ждут"},
+   {"мужской": "ждал", "женский": "ждала", "средний": "ждало", "множественное": "ждали"})
+
+ir("звать",
+   {"я": "зову", "ты": "зовёшь", "он/она/оно": "зовёт", "мы": "зовём", "вы": "зовёте", "они": "зовут"},
+   {"мужской": "звал", "женский": "звала", "средний": "звало", "множественное": "звали"})
+
+ir("слать",
+   {"я": "шлю", "ты": "шлёшь", "он/она/оно": "шлёт", "мы": "шлём", "вы": "шлёте", "они": "шлют"},
+   {"мужской": "слал", "женский": "слала", "средний": "слало", "множественное": "слали"})
+
+# -ва- insert verbs
+ir("вставать",
+   {"я": "встаю", "ты": "встаёшь", "он/она/оно": "встаёт", "мы": "встаём", "вы": "встаёте", "они": "встают"},
+   {"мужской": "вставал", "женский": "вставала", "средний": "вставало", "множественное": "вставали"})
+
+ir("давать",
+   {"я": "даю", "ты": "даёшь", "он/она/оно": "даёт", "мы": "даём", "вы": "даёте", "они": "дают"},
+   {"мужской": "давал", "женский": "давала", "средний": "давало", "множественное": "давали"})
+
+ir("узнавать",
+   {"я": "узнаю", "ты": "узнаёшь", "он/она/оно": "узнаёт", "мы": "узнаём", "вы": "узнаёте", "они": "узнают"},
+   {"мужской": "узнавал", "женский": "узнавала", "средний": "узнавало", "множественное": "узнавали"})
+
+ir("продавать",
+   {"я": "продаю", "ты": "продаёшь", "он/она/оно": "продаёт", "мы": "продаём", "вы": "продаёте", "они": "продают"},
+   {"мужской": "продавал", "женский": "продавала", "средний": "продавало", "множественное": "продавали"})
+
+ir("создавать",
+   {"я": "создаю", "ты": "создаёшь", "он/она/оно": "создаёт", "мы": "создаём", "вы": "создаёте", "они": "создают"},
+   {"мужской": "создавал", "женский": "создавала", "средний": "создавало", "множественное": "создавали"})
+
+# -ыть verbs
+ir("мыть",
+   {"я": "мою", "ты": "моешь", "он/она/оно": "моет", "мы": "моем", "вы": "моете", "они": "моют"},
+   {"мужской": "мыл", "женский": "мыла", "средний": "мыло", "множественное": "мыли"})
+
+ir("крыть",
+   {"я": "крою", "ты": "кроешь", "он/она/оно": "кроет", "мы": "кроем", "вы": "кроете", "они": "кроют"},
+   {"мужской": "крыл", "женский": "крыла", "средний": "крыло", "множественное": "крыли"})
+
+ir("рыть",
+   {"я": "рою", "ты": "роешь", "он/она/оно": "роет", "мы": "роем", "вы": "роете", "они": "роют"},
+   {"мужской": "рыл", "женский": "рыла", "средний": "рыло", "множественное": "рыли"})
+
+# Perfective of -ыть verbs
+ir("открыть", None,
+   {"мужской": "открыл", "женский": "открыла", "средний": "открыло", "множественное": "открыли"},
+   {"я": "открою", "ты": "откроешь", "он/она/оно": "откроет", "мы": "откроем", "вы": "откроете", "они": "откроют"})
+
+ir("закрыть", None,
+   {"мужской": "закрыл", "женский": "закрыла", "средний": "закрыло", "множественное": "закрыли"},
+   {"я": "закрою", "ты": "закроешь", "он/она/оно": "закроет", "мы": "закроем", "вы": "закроете", "они": "закроют"})
+
+# Regular reflexives (fully spelled out due to -ся rules)
+ir("улыбаться",
+   {"я": "улыбаюсь", "ты": "улыбаешься", "он/она/оно": "улыбается", "мы": "улыбаемся", "вы": "улыбаетесь", "они": "улыбаются"},
+   {"мужской": "улыбался", "женский": "улыбалась", "средний": "улыбалось", "множественное": "улыбались"})
+
+ir("купаться",
+   {"я": "купаюсь", "ты": "купаешься", "он/она/оно": "купается", "мы": "купаемся", "вы": "купаетесь", "они": "купаются"},
+   {"мужской": "купался", "женский": "купалась", "средний": "купалось", "множественное": "купались"})
+
+ir("одеваться",
+   {"я": "одеваюсь", "ты": "одеваешься", "он/она/оно": "одевается", "мы": "одеваемся", "вы": "одеваетесь", "они": "одеваются"},
+   {"мужской": "одевался", "женский": "одевалась", "средний": "одевалось", "множественное": "одевались"})
+
+ir("умываться",
+   {"я": "умываюсь", "ты": "умываешься", "он/она/оно": "умывается", "мы": "умываемся", "вы": "умываетесь", "они": "умываются"},
+   {"мужской": "умывался", "женский": "умывалась", "средний": "умывалось", "множественное": "умывались"})
+
+ir("просыпаться",
+   {"я": "просыпаюсь", "ты": "просыпаешься", "он/она/оно": "просыпается", "мы": "просыпаемся", "вы": "просыпаетесь", "они": "просыпаются"},
+   {"мужской": "просыпался", "женский": "просыпалась", "средний": "просыпалось", "множественное": "просыпались"})
+
+ir("ложиться",
+   {"я": "ложусь", "ты": "ложишься", "он/она/оно": "ложится", "мы": "ложимся", "вы": "ложитесь", "они": "ложатся"},
+   {"мужской": "ложился", "женский": "ложилась", "средний": "ложилось", "множественное": "ложились"})
+
+ir("садиться",
+   {"я": "сажусь", "ты": "садишься", "он/она/оно": "садится", "мы": "садимся", "вы": "садитесь", "они": "садятся"},
+   {"мужской": "садился", "женский": "садилась", "средний": "садилось", "множественное": "садились"})
+
+ir("бояться",
+   {"я": "боюсь", "ты": "боишься", "он/она/оно": "боится", "мы": "боимся", "вы": "боитесь", "они": "боятся"},
+   {"мужской": "боялся", "женский": "боялась", "средний": "боялось", "множественное": "боялись"})
+
+ir("смеяться",
+   {"я": "смеюсь", "ты": "смеёшься", "он/она/оно": "смеётся", "мы": "смеёмся", "вы": "смеётесь", "они": "смеются"},
+   {"мужской": "смеялся", "женский": "смеялась", "средний": "смеялось", "множественное": "смеялись"})
+
+ir("надеяться",
+   {"я": "надеюсь", "ты": "надеешься", "он/она/оно": "надеется", "мы": "надеемся", "вы": "надеетесь", "они": "надеются"},
+   {"мужской": "надеялся", "женский": "надеялась", "средний": "надеялось", "множественное": "надеялись"})
+
+ir("кататься",
+   {"я": "катаюсь", "ты": "катаешься", "он/она/оно": "катается", "мы": "катаемся", "вы": "катаетесь", "они": "катаются"},
+   {"мужской": "катался", "женский": "каталась", "средний": "каталось", "множественное": "катались"})
+
+ir("собираться",
+   {"я": "собираюсь", "ты": "собираешься", "он/она/оно": "собирается", "мы": "собираемся", "вы": "собираетесь", "они": "собираются"},
+   {"мужской": "собирался", "женский": "собиралась", "средний": "собиралось", "множественное": "собирались"})
+
+ir("казаться",
+   {"я": "кажусь", "ты": "кажешься", "он/она/оно": "кажется", "мы": "кажемся", "вы": "кажетесь", "они": "кажутся"},
+   {"мужской": "казался", "женский": "казалась", "средний": "казалось", "множественное": "казались"})
+
+
+VERBS = {}
+
+def conj2_stem(verb):
+    if verb.endswith("ить"):
+        return verb[:-3]
+    if verb.endswith("еть"):
+        return verb[:-3]
+    if verb.endswith("ать"):
+        return verb[:-3]
+    return verb[:-2]
+
+def add(verb, conj, aspect, refl=False, stem=None, mut_1sg=None):
+    entry = {"conj": conj, "aspect": aspect, "refl": refl}
+    if stem:
+        entry["stem"] = stem
+    if mut_1sg:
+        entry["mut_1sg"] = mut_1sg
+    VERBS[verb] = entry
+
+# Regular 1st conj verbs (vowel-stem: чита, дела, etc.)
+for v in ["читать","делать","играть","работать","думать","знать","понимать",
+          "слушать","гулять","кушать","обедать","ужинать","завтракать",
+          "отдыхать","встречать","отвечать","спрашивать","повторять",
+          "изучать","начинать","кончать","мечтать","желать","менять",
+          "терять","бросать","кидать","ломать","хватать","купать",
+           "опаздывать","сделать","прочитать","уметь","жалеть","худеть",
+           "толстеть","успеть","поспеть","созреть",
+           "бегать","плавать","летать","лазать","ползать"]:
+    asp = "perf" if v in ("сделать","прочитать","успеть","поспеть","созреть") else "imp"
+    add(v, 1, asp)
+
+# Sibilant-stem 1st conj (писать, искать, etc.)
+for v, s, a in [("писать","пиш","imp"),("искать","ищ","imp"),
+                ("резать","реж","imp"),("мазать","маж","imp"),
+                ("плакать","плач","imp"),("пахать","паш","imp"),
+                ("скакать","скач","imp"),
+                ("написать","напиш","perf"),("сказать","скаж","perf"),
+                ("рассказать","расскаж","perf")]:
+    add(v, 1, a, stem=s)
+
+# -овать verbs (stem in -уj)
+for v in ["рисовать","танцевать","целовать","советовать","требовать",
+          "чувствовать","интересовать","участвовать","существовать",
+          "рекомендовать","воевать","ночевать","попробовать"]:
+    add(v, 1, "perf" if v == "попробовать" else "imp", stem=v[:-5] + "уj")
+
+# -нуть verbs
+for v in ["прыгнуть","крикнуть","стукнуть","толкнуть","махнуть","вернуть","отдохнуть"]:
+    add(v, 1, "perf", stem=v[:-4] + "н")
+
+# замёрзнуть drops -ну- in past: замёрз, замёрзла, замёрзло, замёрзли
+ir("замёрзнуть", None,
+   {"мужской": "замёрз", "женский": "замёрзла", "средний": "замёрзло", "множественное": "замёрзли"},
+   {"я": "замёрзну", "ты": "замёрзнешь", "он/она/оно": "замёрзнет", "мы": "замёрзнем", "вы": "замёрзнете", "они": "замёрзнут"})
+
+# Add all IRR verbs to VERBS
+for verb in IRR:
+    conj = 2 if verb in ("есть","бежать","бояться",) else 1
+    refl = verb.endswith("ся")
+    asp = "imp"
+    if verb in ("дать","взять","понять","начать","помочь","прийти","пройти",
+                "найти","открыть","закрыть","купить","обидеть","увидеть",
+                "посмотреть","услышать","открыть","закрыть","ошибиться",
+                "пустить","простить","приготовить","встретить","объяснить",
+                "кончить","закончить","написать","сказать","рассказать",
+                "сделать","прочитать","успеть","поспеть","созреть","попробовать",
+                "прыгнуть","крикнуть","стукнуть","толкнуть","махнуть","вернуть",
+                "отдохнуть","замёрзнуть"):
+        asp = "perf"
+    add(verb, conj, asp, refl=refl)
+
+# Regular 2nd conj -ить verbs
+for v, a, m in [("говорить","imp","говорю"),("любить","imp","люблю"),
+                ("купить","perf","куплю"),("носить","imp","ношу"),
+                ("ходить","imp","хожу"),("просить","imp","прошу"),
+                ("возить","imp","вожу"),("платить","imp","плачу"),
+                ("крутить","imp","кручу"),("варить","imp","варю"),
+                ("дарить","imp","дарю"),("готовить","imp","готовлю"),
+                ("ловить","imp","ловлю"),("ставить","imp","ставлю"),
+                ("тратить","imp","трачу"),("пустить","perf","пущу"),
+                ("простить","perf","прощу"),("грустить","imp","грущу"),
+                ("чистить","imp","чищу"),("ездить","imp","езжу"),
+                ("кончить","perf","кончу"),("закончить","perf","закончу"),
+                ("объяснить","perf","объясню"),
+                ("приготовить","perf","приготовлю"),
+                ("встретить","perf","встречу")]:
+    add(v, 2, a, stem=conj2_stem(v), mut_1sg=m)
+
+# 2nd conj -еть exceptions
+for v, a, m in [("сидеть","imp","сижу"),("висеть","imp","вишу"),
+                ("лететь","imp","лечу"),("шуметь","imp","шумлю"),
+                ("смотреть","imp","смотрю"),("видеть","imp","вижу"),
+                ("ненавидеть","imp","ненавижу"),("терпеть","imp","терплю"),
+                ("обидеть","perf","обижу"),("зависеть","imp","завишу"),
+                ("вертеть","imp","верчу"),
+                ("увидеть","perf","увижу"),("посмотреть","perf","посмотрю")]:
+    add(v, 2, a, stem=conj2_stem(v), mut_1sg=m)
+
+# 2nd conj -ать exceptions
+for v, a in [("слышать","imp"),("держать","imp"),("дышать","imp"),
+             ("гнать","imp"),("лежать","imp"),("молчать","imp"),
+             ("кричать","imp"),("звучать","imp"),("стучать","imp"),
+             ("услышать","perf")]:
+    add(v, 2, a, stem=conj2_stem(v))
+
+# спать (special 1sg mutation)
+for v, a, m in [("спать","imp","сплю")]:
+    add(v, 2, a, stem=conj2_stem(v), mut_1sg=m)
+
+
+# --- Classify exceptions for every verb ---
+def _build_exceptions():
+    truly_irregular = {"быть","дать","есть","хотеть","ехать","бежать","взять",
+                       "понять","начать","ошибиться","замёрзнуть"}
+
+    for verb, info in VERBS.items():
+        exc = []
+
+        if verb in truly_irregular:
+            exc.append("irregular")
+
+        # conj_class: 2nd conj but ending in -еть/-ать (normally 1st conj endings)
+        if info["conj"] == 2 and not verb.endswith("ить") and verb not in ("спать",):
+            if verb.endswith("еть") or verb.endswith("ать") or verb.endswith("ять"):
+                exc.append("conj_class")
+        if verb == "спать":
+            exc.append("conj_class")
+
+        if "mut_1sg" in info:
+            exc.append("mut_1sg")
+
+        if "stem" in info:
+            s = info["stem"]
+            if s.endswith("j"):
+                exc.append("stem_change")
+            else:
+                exc.append("sibilant_stem")
+
+        if verb.endswith("нуть") and verb not in truly_irregular:
+            exc.append("nut_verb")
+
+        if verb.endswith("ся"):
+            exc.append("reflexive")
+
+        # past_irreg: compare generated past with actual past from IRR
+        if verb in IRR and IRR[verb].get("past"):
+            try:
+                irr_past = IRR[verb]["past"]
+                if verb.endswith("ть"):
+                    stem = verb[:-2]
+                elif verb.endswith("ти"):
+                    stem = verb[:-2]
+                elif verb.endswith("чь"):
+                    stem = verb[:-2]
+                else:
+                    stem = verb
+                expected = {"мужской": stem+"л", "женский": stem+"ла",
+                            "средний": stem+"ло", "множественное": stem+"ли"}
+                if irr_past != expected:
+                    exc.append("past_irreg")
+            except Exception:
+                exc.append("past_irreg")
+
+        if exc:
+            EXCEPTIONS[verb] = exc
+
+_build_exceptions()
+
+
+def get_exceptions():
+    return {v: {"types": t, "descriptions": [EXCEPTION_TYPES[e] for e in t]}
+            for v, t in EXCEPTIONS.items()}
+
+
+def get_verb_exceptions(verb):
+    exc = EXCEPTIONS.get(verb)
+    if not exc:
+        return None
+    return {"verb": verb, "types": exc, "descriptions": [EXCEPTION_TYPES[e] for e in exc]}
+
+
+VOWELS = set("аеёиоуыэюя")
+
+def conj1_present(stem):
+    if stem.endswith("j"):
+        stem = stem[:-1]
+    def e(p):
+        if p == 0:
+            if stem and stem[-1] in SIBILANTS:
+                return stem + "у"
+            if stem and stem[-1] in VOWELS:
+                return stem + "ю"
+            return stem + "у"
+        if p == 5:
+            if stem and stem[-1] in SIBILANTS:
+                return stem + "ут"
+            if stem and stem[-1] in VOWELS:
+                return stem + "ют"
+            return stem + "ут"
+        return stem + ["ешь","ет","ем","ете"][p-1]
+    return {PERSONS[i]: e(i) for i in range(6)}
+
+
+def conj2_present(stem, mut_1sg=None):
+    def e(p):
+        if p == 0:
+            return mut_1sg if mut_1sg else stem + "ю"
+        if p == 5:
+            if stem and stem[-1] in SIBILANTS:
+                return stem + "ат"
+            return stem + "ят"
+        return stem + ["ишь","ит","им","ите"][p-1]
+    return {PERSONS[i]: e(i) for i in range(6)}
+
+
+def build_past(verb):
+    if verb.endswith("ть"):
+        s = verb[:-2]
+    elif verb.endswith("ти"):
+        s = verb[:-2]
+    elif verb.endswith("чь"):
+        s = verb[:-2]
+    else:
+        s = verb
+    return {"мужской": s+"л", "женский": s+"ла", "средний": s+"ло", "множественное": s+"ли"}
+
+
+
+def conjugate(verb):
+    verb = verb.lower().strip()
+    info = VERBS.get(verb)
+    if not info:
+        return conjugate_any(verb)
+
+    if verb in IRR:
+        irr = IRR[verb]
+        tenses = {
+            "present": irr["present"],
+            "past": irr["past"],
+        }
+        if info["aspect"] == "imp" and verb != "быть":
+            bp = {"я": "буду", "ты": "будешь", "он/она/оно": "будет",
+                  "мы": "будем", "вы": "будете", "они": "будут"}
+            tenses["future"] = {p: f"{b} {verb}" for p, b in bp.items()}
+        else:
+            f = irr.get("future")
+            if f:
+                tenses["future"] = f
+            elif info["aspect"] == "perf":
+                stem = info.get("stem", verb[:-2] if verb.endswith("ть") else verb)
+                if info["conj"] == 1:
+                    tenses["future"] = conj1_present(stem)
+                else:
+                    tenses["future"] = conj2_present(stem, info.get("mut_1sg"))
+        if info["aspect"] == "perf" and verb not in ("быть",):
+            tenses["present"] = None
+        return build_result(verb, info, tenses), 200
+
+    stem = info.get("stem", verb[:-2] if verb.endswith("ть") else verb)
+    tenses = {}
+
+    if info["conj"] == 1:
+        tenses["present"] = conj1_present(stem)
+    else:
+        tenses["present"] = conj2_present(stem, info.get("mut_1sg"))
+
+    tenses["past"] = build_past(verb)
+
+    if info["aspect"] == "perf":
+        tenses["present"] = None
+        if info["conj"] == 1:
+            tenses["future"] = conj1_present(stem)
+        else:
+            tenses["future"] = conj2_present(stem, info.get("mut_1sg"))
+    else:
+        bp = {"я": "буду", "ты": "будешь", "он/она/оно": "будет",
+              "мы": "будем", "вы": "будете", "они": "будут"}
+        tenses["future"] = {p: f"{b} {verb}" for p, b in bp.items()}
+
+    return build_result(verb, info, tenses), 200
+
+
+def build_result(verb, info, tenses):
+    aspect_map = {"imp": "imperfective", "perf": "perfective"}
+    result = {
+        "verb": verb,
+        "aspect": aspect_map.get(info["aspect"], info["aspect"]),
+        "conjugation_type": info["conj"],
+        "reflexive": info["refl"],
+        "tenses": tenses,
+    }
+    exc = get_verb_exceptions(verb)
+    if exc:
+        result["exceptions"] = exc
+    return result
+
+
+# --- Rule-based fallback for any Russian verb ---
+
+SECOND_CONJ_EXCEPTIONS = {
+    "сидеть","висеть","лететь","шуметь","смотреть","видеть",
+    "ненавидеть","терпеть","обидеть","зависеть","вертеть",
+    "увидеть","посмотреть",
+    "слышать","держать","дышать","гнать","лежать","молчать",
+    "кричать","звучать","стучать","услышать","спать",
+}
+
+def _add_refl(form):
+    if form and form[-1] in VOWELS:
+        return form + "сь"
+    return form + "ся"
+
+def _reflexivize(tenses):
+    for tense_key in list(tenses.keys()):
+        if tense_key in ("past", "future"):
+            continue
+        if tenses[tense_key] is None:
+            continue
+        forms = {}
+        for person, form in tenses[tense_key].items():
+            forms[person] = _add_refl(form)
+        tenses[tense_key] = forms
+    return tenses
+
+def _past_of(verb):
+    if verb.endswith("ся"):
+        base = verb[:-2]
+    else:
+        base = verb
+    if base.endswith("ть"):
+        s = base[:-2]
+    elif base.endswith("ти"):
+        s = base[:-2]
+    elif base.endswith("чь"):
+        s = base[:-2]
+    else:
+        s = base
+    past = {"мужской": s+"л", "женский": s+"ла", "средний": s+"ло", "множественное": s+"ли"}
+    if verb.endswith("ся"):
+        return {"мужской": past["мужской"]+"ся",
+                "женский": past["женский"]+"сь",
+                "средний": past["средний"]+"сь",
+                "множественное": past["множественное"]+"сь"}
+    return past
+
+def _conj_number(verb):
+    if verb.endswith("ся"):
+        verb = verb[:-2]
+    if verb.endswith("ить"):
+        return 2
+    if verb in SECOND_CONJ_EXCEPTIONS:
+        return 2
+    return 1
+
+def _guess_mutation(stem):
+    if not stem:
+        return None
+    non_mutating = set("рлнкгхжшчщй")
+    if stem[-1] in non_mutating:
+        return None
+    if stem.endswith("ст"):
+        return stem[:-2] + "щ"
+    if stem.endswith("зд"):
+        return stem[:-2] + "жд"
+    if stem.endswith("д"):
+        return stem[:-1] + "ж"
+    if stem.endswith("з"):
+        return stem[:-1] + "ж"
+    if stem.endswith("с"):
+        return stem[:-1] + "ш"
+    if stem.endswith("т"):
+        return stem[:-1] + "ч"
+    if stem.endswith("в"):
+        return stem[:-1] + "вл"
+    if stem.endswith("б"):
+        return stem[:-1] + "бл"
+    if stem.endswith("п"):
+        return stem[:-1] + "пл"
+    if stem.endswith("м"):
+        return stem[:-1] + "мл"
+    if stem.endswith("ф"):
+        return stem[:-1] + "фл"
+    return None
+
+def _present_stem(verb):
+    if verb.endswith("ся"):
+        base = verb[:-2]
+    else:
+        base = verb
+    if base.endswith("овать"):
+        return base[:-5] + "уj"
+    if base.endswith("евать"):
+        return base[:-5] + "уj"
+    if base.endswith("нуть"):
+        return base[:-4] + "н"
+    if base.endswith("ить"):
+        return base[:-3]
+    if base.endswith("чь"):
+        return base[:-2]
+    if base.endswith("ти"):
+        return base[:-2]
+    if base.endswith("ть"):
+        return base[:-2]
+    return base
+
+def conjugate_any(verb):
+    verb = verb.lower().strip()
+    refl = verb.endswith("ся")
+    conj = _conj_number(verb)
+    stem = _present_stem(verb)
+    mut = _guess_mutation(stem) if conj == 2 else None
+    tenses = {}
+    tenses["past"] = _past_of(verb)
+    if conj == 2:
+        tenses["present"] = conj2_present(stem, mut)
+    else:
+        tenses["present"] = conj1_present(stem)
+    bp = {"я": "буду", "ты": "будешь", "он/она/оно": "будет",
+          "мы": "будем", "вы": "будете", "они": "будут"}
+    tenses["future"] = {p: f"{b} {verb}" for p, b in bp.items()}
+    if refl:
+        tenses = _reflexivize(tenses)
+    info = {"conj": conj, "aspect": "imp", "refl": refl, "stem": stem}
+    if mut:
+        info["mut_1sg"] = mut
+    result = build_result(verb, info, tenses)
+    result["generated_by_rules"] = True
+    return result, 200
+
+
+def search_verbs(query):
+    q = query.lower()
+    results = []
+    for verb in VERBS:
+        if q in verb.lower():
+            info = VERBS[verb]
+            results.append({
+                "verb": verb,
+                "aspect": "imperfective" if info["aspect"] == "imp" else "perfective",
+                "reflexive": info["refl"],
+            })
+    return sorted(results, key=lambda x: x["verb"])
+
+
+def list_verbs():
+    results = []
+    for verb, info in sorted(VERBS.items()):
+        results.append({
+            "verb": verb,
+            "aspect": "imperfective" if info["aspect"] == "imp" else "perfective",
+            "reflexive": info["refl"],
+        })
+    return results

ru_api_free/dictionary.py

@@ -0,0 +1,21 @@
+from deep_translator import GoogleTranslator
+
+_translator = None
+
+def get_translator():
+    global _translator
+    if _translator is None:
+        _translator = GoogleTranslator(source="en", target="ru")
+    return _translator
+
+
+def translate_en_to_ru(word):
+    word = word.lower().strip()
+    try:
+        t = get_translator()
+        result = t.translate(word)
+        if result and result.lower() != word.lower():
+            return result.lower()
+    except Exception:
+        pass
+    return None

ru_api_free/main.py

@@ -0,0 +1,95 @@
+from fastapi import FastAPI, Query, HTTPException, Path
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+
+from .conjugator import conjugate, search_verbs, list_verbs, get_exceptions, get_verb_exceptions, EXCEPTION_TYPES
+from .dictionary import translate_en_to_ru
+
+app = FastAPI(
+    title="Russian Verb Conjugation API",
+    description="Free API for conjugating Russian verbs in all tenses (present, past, future)",
+    version="1.0.0",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+import importlib.resources as res
+
+try:
+    static_path = res.files("ru_api_free").joinpath("static")
+    if static_path.is_dir():
+        app.mount("/site", StaticFiles(directory=str(static_path), html=True), name="static")
+except Exception:
+    pass
+
+
+@app.get("/")
+def root():
+    return {
+        "name": "Russian Verb Conjugation API",
+        "version": "1.0.0",
+        "endpoints": {
+            "/conjugate?verb={verb}": "Get full conjugation of a Russian verb",
+            "/translate?english={word}": "Enter an English verb, get Russian conjugation",
+            "/verbs": "List all available verbs",
+            "/search?q={query}": "Search for verbs",
+            "/exceptions": "List all verbs with conjugation exceptions",
+            "/exceptions/{verb}": "Get exceptions for a specific verb",
+            "/site": "Open the conjugation web UI",
+        },
+        "docs": "/docs",
+    }
+
+
+@app.get("/conjugate")
+def get_conjugation(verb: str = Query(..., description="Russian verb in infinitive form (e.g., читать)")):
+    result, status_code = conjugate(verb)
+    return result
+
+
+@app.get("/verbs")
+def get_all_verbs():
+    return {"verbs": list_verbs(), "count": len(list_verbs())}
+
+
+@app.get("/exceptions")
+def get_all_exceptions(exception_type: str = Query(None, description="Filter by exception type (e.g., mut_1sg, conj_class, irregular)")):
+    exceptions = get_exceptions()
+    if exception_type:
+        filtered = {v: d for v, d in exceptions.items() if exception_type in d["types"]}
+        return {"exception_type": exception_type, "description": EXCEPTION_TYPES.get(exception_type, ""), "verbs": filtered, "count": len(filtered)}
+    return {"exception_types": EXCEPTION_TYPES, "verbs": exceptions, "count": len(exceptions)}
+
+
+@app.get("/exceptions/{verb}")
+def exceptions_for_verb(verb: str = Path(..., description="Russian verb infinitive")):
+    exc = get_verb_exceptions(verb.lower().strip())
+    if exc is None:
+        return {"verb": verb, "exception": None, "message": "This verb follows standard conjugation rules (no exceptions)"}
+    return exc
+
+
+@app.get("/search")
+def search(query: str = Query(..., description="Search query for verb (e.g., чит)")):
+    results = search_verbs(query)
+    return {"query": query, "results": results, "count": len(results)}
+
+
+@app.get("/translate")
+def translate_to_russian(english: str = Query(..., description="English verb (e.g., read)")):
+    eng = english.lower().strip()
+    ru_word = translate_en_to_ru(eng)
+    if not ru_word:
+        raise HTTPException(status_code=502, detail="Translation service unavailable")
+    result, status_code = conjugate(ru_word)
+    result["english"] = eng
+    result["translated"] = ru_word
+    if result.get("generated_by_rules"):
+        result["note"] = f"Conjugation generated by rules; '{ru_word}' was not in the exact verb database"
+    return result

ru_api_free/static/index.html

@@ -0,0 +1,213 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Russian Verb Conjugation</title>
+<style>
+* { box-sizing: border-box; margin: 0; padding: 0; }
+body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #0f172a; color: #e2e8f0; min-height: 100vh; display: flex; flex-direction: column; align-items: center; padding: 2rem 1rem; }
+.container { width: 100%; max-width: 800px; }
+h1 { font-size: 1.8rem; font-weight: 700; margin-bottom: 0.25rem; background: linear-gradient(135deg, #60a5fa, #a78bfa); -webkit-background-clip: text; -webkit-text-fill-color: transparent; }
+.subtitle { color: #94a3b8; margin-bottom: 1.5rem; font-size: 0.9rem; }
+.search-box { display: flex; gap: 0.5rem; margin-bottom: 1.5rem; }
+input { flex: 1; padding: 0.75rem 1rem; border: 1px solid #334155; border-radius: 8px; font-size: 1rem; background: #1e293b; color: #e2e8f0; outline: none; transition: border 0.2s; }
+input:focus { border-color: #60a5fa; }
+input::placeholder { color: #64748b; }
+button { padding: 0.75rem 1.5rem; background: linear-gradient(135deg, #60a5fa, #a78bfa); border: none; border-radius: 8px; color: #fff; font-size: 1rem; font-weight: 600; cursor: pointer; transition: opacity 0.2s; white-space: nowrap; }
+button:hover { opacity: 0.9; }
+button:disabled { opacity: 0.5; cursor: not-allowed; }
+.hint { color: #94a3b8; font-size: 0.8rem; margin-bottom: 1.5rem; }
+.hint span { display: inline-block; background: #1e293b; padding: 0.15rem 0.5rem; border-radius: 4px; margin: 0.15rem; cursor: pointer; transition: background 0.2s; }
+.hint span:hover { background: #334155; }
+.error { background: #7f1d1d; color: #fca5a5; padding: 0.75rem 1rem; border-radius: 8px; margin-bottom: 1rem; display: none; }
+.loading { text-align: center; padding: 2rem; display: none; }
+.loading::after { content: ''; display: inline-block; width: 2rem; height: 2rem; border: 3px solid #334155; border-top-color: #60a5fa; border-radius: 50%; animation: spin 0.6s linear infinite; }
+@keyframes spin { to { transform: rotate(360deg); } }
+.card { background: #1e293b; border-radius: 12px; padding: 1.5rem; margin-bottom: 1rem; display: none; }
+.card-header { display: flex; justify-content: space-between; align-items: center; margin-bottom: 1rem; flex-wrap: wrap; gap: 0.5rem; }
+.card-header h2 { font-size: 1.2rem; }
+.badge { display: inline-block; padding: 0.2rem 0.6rem; border-radius: 999px; font-size: 0.75rem; font-weight: 600; }
+.badge-imp { background: #1e3a5f; color: #93c5fd; }
+.badge-perf { background: #3b1e5f; color: #c4a5fd; }
+.badge-refl { background: #1e5f3b; color: #a5fdc4; }
+.verb-meta { display: flex; gap: 0.5rem; flex-wrap: wrap; }
+.tenses { display: grid; gap: 1rem; }
+.tense-block { }
+.tense-block h3 { font-size: 0.85rem; text-transform: uppercase; letter-spacing: 0.05em; color: #94a3b8; margin-bottom: 0.5rem; }
+table { width: 100%; border-collapse: collapse; font-size: 0.9rem; }
+td { padding: 0.4rem 0.6rem; border-bottom: 1px solid #334155; }
+td:first-child { color: #94a3b8; width: 30%; }
+td:last-child { font-weight: 500; }
+.empty-tense { color: #64748b; font-style: italic; padding: 0.5rem 0; }
+.suggestions { display: flex; gap: 0.5rem; flex-wrap: wrap; margin-top: 0.5rem; }
+.suggestions button { font-size: 0.8rem; padding: 0.3rem 0.8rem; }
+@media (max-width: 600px) {
+  .search-box { flex-direction: column; }
+  body { padding: 1rem; }
+}
+</style>
+</head>
+<body>
+<div class="container">
+  <h1>Russian Verb Conjugation</h1>
+    <p class="subtitle" id="noteMsg" style="display:none;color:#fbbf24;font-size:0.8rem;margin-bottom:0.75rem;"></p>
+    <p class="subtitle">Enter a verb in English or Russian to see all tenses</p>
+  <div class="search-box">
+    <input type="text" id="verbInput" placeholder="e.g. read, speak, писать, говорить..." autofocus>
+    <button id="searchBtn">Conjugate</button>
+  </div>
+  <div class="hint">
+    Try: <span>read</span> <span>speak</span> <span>eat</span> <span>be</span> <span>run</span> <span>читать</span> <span>говорить</span>
+  </div>
+  <div class="error" id="errorMsg"></div>
+  <div class="loading" id="loading"></div>
+  <div class="card" id="resultCard">
+    <div class="card-header">
+      <h2 id="verbTitle"></h2>
+      <div class="verb-meta" id="verbMeta"></div>
+    </div>
+    <div class="tenses" id="tensesContainer"></div>
+    <div class="suggestions" id="suggestionsContainer"></div>
+  </div>
+</div>
+<script>
+const input = document.getElementById('verbInput');
+const searchBtn = document.getElementById('searchBtn');
+const errorMsg = document.getElementById('errorMsg');
+const loading = document.getElementById('loading');
+const resultCard = document.getElementById('resultCard');
+
+const API_BASE = window.location.origin;
+
+document.querySelectorAll('.hint span').forEach(el => {
+  el.addEventListener('click', () => { input.value = el.textContent; searchVerb(); });
+});
+
+input.addEventListener('keydown', e => { if (e.key === 'Enter') searchVerb(); });
+searchBtn.addEventListener('click', searchVerb);
+
+async function searchVerb() {
+  const query = input.value.trim();
+  if (!query) return;
+  errorMsg.style.display = 'none';
+  resultCard.style.display = 'none';
+  loading.style.display = 'block';
+  try {
+    const isCyrillic = /[а-яё]/i.test(query);
+    let data;
+    if (isCyrillic) {
+      const res = await fetch(`${API_BASE}/conjugate?verb=${encodeURIComponent(query)}`);
+      if (!res.ok) throw { status: res.status, msg: (await res.json()).detail || 'Verb not found' };
+      data = await res.json();
+    } else {
+      const res = await fetch(`${API_BASE}/translate?english=${encodeURIComponent(query)}`);
+      if (!res.ok) {
+        const body = await res.json();
+        if (body.suggestions) {
+          showSuggestions(body.suggestions);
+          throw null;
+        }
+        throw { status: res.status, msg: body.detail || 'Verb not found' };
+      }
+      data = await res.json();
+    }
+    renderResult(data);
+  } catch (err) {
+    if (err) showError(err.msg || 'An error occurred');
+  } finally {
+    loading.style.display = 'none';
+  }
+}
+
+function showSuggestions(suggestions) {
+  const container = document.getElementById('suggestionsContainer');
+  container.innerHTML = '<p style="color:#94a3b8;font-size:0.85rem;width:100%;">Did you mean:</p>' +
+    suggestions.map(s => `<button onclick="trySuggestion('${s}')">${s}</button>`).join('');
+}
+
+function trySuggestion(word) {
+  input.value = word;
+  searchVerb();
+}
+
+function renderResult(data) {
+  resultCard.style.display = 'block';
+  document.getElementById('suggestionsContainer').innerHTML = '';
+  const noteMsg = document.getElementById('noteMsg');
+  if (data.note) {
+    noteMsg.textContent = data.note;
+    noteMsg.style.display = 'block';
+  } else {
+    noteMsg.style.display = 'none';
+  }
+
+  const hasExceptions = data.exceptions;
+  document.getElementById('verbTitle').innerHTML = `
+    ${data.verb}
+    ${data.english ? `<span style="color:#94a3b8;font-size:0.8rem;font-weight:400;margin-left:0.5rem">(${data.english})</span>` : ''}
+  `;
+
+  const meta = document.getElementById('verbMeta');
+  meta.innerHTML = `
+    <span class="badge ${data.aspect === 'imperfective' ? 'badge-imp' : 'badge-perf'}">${data.aspect}</span>
+    <span class="badge" style="background:#1e293b;color:#94a3b8">Type ${data.conjugation_type} conjugation</span>
+    ${data.reflexive ? '<span class="badge badge-refl">reflexive</span>' : ''}
+    ${hasExceptions ? '<span class="badge" style="background:#5f3b1e;color:#fdc4a5">exceptions</span>' : ''}
+  `;
+
+  const container = document.getElementById('tensesContainer');
+  container.innerHTML = '';
+
+  const tenseLabels = {
+    present: 'Present Tense (Настоящее время)',
+    future: 'Future Tense (Будущее время)',
+    past: 'Past Tense (Прошедшее время)'
+  };
+
+  for (const [tense, forms] of Object.entries(data.tenses)) {
+    const block = document.createElement('div');
+    block.className = 'tense-block';
+    block.innerHTML = `<h3>${tenseLabels[tense] || tense}</h3>`;
+
+    if (forms === null) {
+      block.innerHTML += '<div class="empty-tense">— (perfective verb; use future for completed actions)</div>';
+    } else if (typeof forms === 'object') {
+      let table = '<table>';
+      if (forms['мужской']) {
+        for (const [gender, val] of Object.entries(forms)) {
+          const label = { мужской: 'Masculine', женский: 'Feminine', средний: 'Neuter', множественное: 'Plural' }[gender] || gender;
+          table += `<tr><td>${label}</td><td>${val}</td></tr>`;
+        }
+      } else {
+        for (const [person, val] of Object.entries(forms)) {
+          table += `<tr><td>${person}</td><td>${val}</td></tr>`;
+        }
+      }
+      table += '</table>';
+      block.innerHTML += table;
+    }
+
+    container.appendChild(block);
+  }
+
+  if (data.exceptions) {
+    const excBlock = document.createElement('div');
+    excBlock.className = 'tense-block';
+    excBlock.innerHTML = '<h3>Exceptions</h3>';
+    const list = data.exceptions.descriptions.map(d => `<div style="padding:0.2rem 0;color:#fde68a;font-size:0.85rem">• ${d}</div>`).join('');
+    excBlock.innerHTML += list;
+    container.appendChild(excBlock);
+  }
+
+  resultCard.scrollIntoView({ behavior: 'smooth', block: 'start' });
+}
+
+function showError(msg) {
+  errorMsg.textContent = msg;
+  errorMsg.style.display = 'block';
+  resultCard.style.display = 'none';
+}
+</script>
+</body>
+</html>

ru_api_free-1.0.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: ru-api-free
+Version: 1.0.0
+Summary: Free API for conjugating Russian verbs in all tenses (present, past, future)
+Author-email: Your Name <your@email.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yourusername/ru-api-free
+Project-URL: Source, https://github.com/yourusername/ru-api-free
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi
+Requires-Dist: uvicorn[standard]
+Requires-Dist: aiofiles
+Requires-Dist: deep_translator
+Dynamic: license-file
+
+# ru-api-free
+
+Free API for conjugating Russian verbs in all tenses (present, past, future).
+
+## Install
+
+```bash
+pip install ru-api-free
+```
+
+## Usage
+
+Start the API server:
+
+```bash
+ru-api-free
+```
+
+Or directly with uvicorn:
+
+```bash
+uvicorn ru_api_free.main:app
+```
+
+The API will be available at `http://localhost:8000`. Open `http://localhost:8000/docs` for interactive documentation.
+
+### Endpoints
+
+| Endpoint | Description |
+|---|---|
+| `GET /conjugate?verb={verb}` | Get full conjugation of a Russian verb |
+| `GET /translate?english={word}` | Enter an English verb, get Russian conjugation |
+| `GET /verbs` | List all available verbs |
+| `GET /search?q={query}` | Search for verbs |
+| `GET /exceptions` | List all verbs with conjugation exceptions |
+| `GET /exceptions/{verb}` | Get exceptions for a specific verb |
+
+## Python API
+
+```python
+from ru_api_free import conjugate
+
+result, status = conjugate("читать")
+print(result)
+```
+
+```python
+from ru_api_free import translate_en_to_ru
+
+russian = translate_en_to_ru("read")
+print(russian)  # читать
+```
+
+## License
+
+MIT

ru_api_free-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+ru_api_free/__init__.py,sha256=4b2MlWqC5GcxSq2GH1-TOSu3rNH5eTwZOMh2lGGACfs,331
+ru_api_free/__main__.py,sha256=NC62rxprEIymRh2r8llyavSLnCNzogUjUKmkoQdvu8w,172
+ru_api_free/conjugator.py,sha256=pyBg52SWE0zRPJp3jy1falG7-qliQn_askkcgRxv0Do,42137
+ru_api_free/dictionary.py,sha256=jtJ-QqGgKiAx6LBEMNpyTAuCV2VW4cBCyojj5X5Cquw,503
+ru_api_free/main.py,sha256=o0Oe7-x_6g_A9EnXsVb6i-qHLMmoEG0Bwv9u1srG1cA,3514
+ru_api_free/static/index.html,sha256=X171o9UwlWsBILBHcZtdt_HojY3EhxPq_6ngtAvfeS8,9565
+ru_api_free-1.0.0.dist-info/licenses/LICENSE,sha256=ESYyLizI0WWtxMeS7rGVcX3ivMezm-HOd5WdeOh-9oU,1056
+ru_api_free-1.0.0.dist-info/METADATA,sha256=lwIoLjBB_VOHFdIDoc8ssPE70pNf84RhZnL3BZTZMlI,2159
+ru_api_free-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+ru_api_free-1.0.0.dist-info/entry_points.txt,sha256=wc92u3NNqbWbri8qI53y2iGk8GWVGgikozQsM5UkVCk,58
+ru_api_free-1.0.0.dist-info/top_level.txt,sha256=b1-HTcAJYK1hKG2EGbIFt5lMo8kf3uvaMoRuo84G7VM,12
+ru_api_free-1.0.0.dist-info/RECORD,,

ru_api_free-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ru_api_free-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ru-api-free = ru_api_free.__main__:main

ru_api_free-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ru_api_free-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ru_api_free