def test_census_origins(self):
a = ety.census('flying aerodynamically')
b = ety.origins('flying')
c = ety.origins('aerodynamically')
self.assertEqual(a.origins(), b + c)
d = ety.census('flying aerodynamically')
e = ety.origins('flying', recursive=True)
f = ety.origins('aerodynamically', recursive=True)
self.assertEqual(d.origins(recursive=True), e + f)
def test_census_origins(self):
a = ety.census("flying aerodynamically")
b = ety.origins("flying")
c = ety.origins("aerodynamically")
self.assertEqual(a.origins(), b + c)
d = ety.census("flying aerodynamically")
e = ety.origins("flying", recursive=True)
f = ety.origins("aerodynamically", recursive=True)
self.assertEqual(d.origins(recursive=True), e + f)
def get_origins(word: str, language_code: str) -> List[Word]:
origins = ety.origins(word, language=language_code, recursive=True)
origins = [ety_to_word(origin) for origin in origins]
# parallelize "lazy-loading" word_to_dict call, which makes an api fetch for each definition
pool = mp.Pool(mp.cpu_count())
serialized_origins = pool.map_async(word_to_dict, origins).get()
pool.close
return serialized_origins
def test_cli_multiple_words(self, output):
words = ["test", "word"]
sys.argv = ["ety.py"] + words
ety.cli()
origins = [origin for word in words for origin in ety.origins(word)]
expected_lines = len(words) + len(origins) + len(words) - 1
self.assertEqual(expected_lines, output.lines)
def test_cli_recursive(self, output):
words = ["test"]
sys.argv = ["ety.py", "-r"] + words
ety.cli()
origins = ety.origins("test", recursive=True)
expected_lines = len(words) + len(origins)
self.assertEqual(expected_lines, output.lines)
def test_cli_no_args(self, output):
words = ["test"]
sys.argv = ["ety.py", "test"]
ety.cli()
origins = ety.origins("test")
expected_lines = len(words) + len(origins)
self.assertEqual(expected_lines, output.lines)
def cli():
"""
Command line interface
:return: Exit code
"""
parser = argparse.ArgumentParser(prog="ety")
parser.add_argument("words",
type=str,
nargs='+',
help="the search word(s)")
parser.add_argument("-r",
"--recursive",
help="search origins recursively",
action="store_true")
parser.add_argument("-t",
"--tree",
help="display etymology tree",
action="store_true")
args = parser.parse_args()
output = ''
for word in args.words:
source_word = ety.Word(word, color=True)
roots = ety.origins(word, recursive=args.recursive)
if not roots:
print("No origins found for word: {}".format(word))
continue
# Bullet point: '\u2022'
if args.tree:
output += '%s\n\n' % str(ety.tree(source_word))
else:
output += '\n\n%s\n \u2022 ' % source_word
output += '\n \u2022 '.join(root.pretty for root in roots)
print(output.strip())
return 0
def getCompleteInfo(word):
dictionary = PyDictionary()
mean = {}
mean = dictionary.meaning(word)
synonyms = []
antonyms = []
speak("Alright. Here is the information you asked for.")
for key in mean.keys():
speak("When " + str(word) + " is used as a " + str(key) +
" then it has the following meanings")
for val in mean[key]:
print(val)
print()
speak("The possible synonyms and antonyms of " + str(word) +
" are given below.")
for syn in wordnet.synsets(word):
for l in syn.lemmas():
if l.name() not in synonyms:
synonyms.append(l.name())
if l.antonyms() and l.antonyms()[0].name() not in antonyms:
antonyms.append(l.antonyms()[0].name())
print("Synonyms: ", end=" ")
print(' '.join(synonyms), end=" ")
print("\n")
print("Antonyms: ", end=" ")
print(' '.join(antonyms), end=" ")
print("\n")
ori = ety.origins(word)
if len(ori) > 0:
speak("There are " + str(len(ori)) + " possible origins found.")
for origin in ori:
print(origin)
else:
speak("I'm sorry. No data regarding the origin of " + str(word) +
" was found.")
def test_circular_etymology():
"""Test to avoid https://github.com/jmsv/ety-python/issues/20
This method is run with a 10 second timeout (see Makefile test)"""
ety.origins('software', recursive=True)
def test_origins_recursion(self):
o = ety.origins(ety.random_word(), recursive=True)
self.assertGreater(len(o), 0)
o = ety.origins('iland', recursive=True)
self.assertGreater(len(o), 0)
def test_origins(self):
word = ety.origins(ety.random_word())
self.assertGreater(len(word), 0)
def find_ety(search):
search = ety.origins(search)
word_origin_list = ""
for word in search:
word_origin_list += str(word)
return word_origin_list
def word_origin(word):
origin = ety.origins(word)
if len(origin) == 0:
return "Undefined"
lang = origin[0].language.name.split('(')[0].strip()
return lang
import re
from typing import Dict, List, Any
import multiprocessing as mp
from pydantic import BaseModel
import ety
from wiktionaryparser import WiktionaryParser
parser = WiktionaryParser()
origin_descendants = {}
for word in ety.data.etyms['eng'].keys():
origins = ety.origins(word, recursive=True)
for origin in origins:
# tuple of the form ('gata', 'Old Norse')
origin = (origin._word, origin._language.iso)
if origin_descendants.get(origin):
origin_descendants[origin].append(word)
else:
origin_descendants[origin] = [word]
class Word(BaseModel):
word: str
language: str = 'English'
language_code: str = 'eng'
meaning: List[Dict[str, Any]] = []
def camel_to_snake(text: str) -> str:
text = re.sub(r'(?<!^)(?=[A-Z])', '_', text).lower()
