Cognates

demo.py

@@ -1,12 +1,12 @@
 from wordstats import Word
 
 
-print Word.stats("maman", "fr")
-print Word.stats("Mutter", "de")
-print Word.stats("Mother", "en")
-print Word.stats("mama", "ro")
+print(str(Word.stats("maman", "fr")))
+print(str(Word.stats("Mutter", "de")))
+print(str(Word.stats("Mother", "en")))
+print(str(Word.stats("mama", "ro")))
 
-print Word.stats("maman", "fr")
-print Word.stats("Mutter", "de")
-print Word.stats("Mother", "en")
-print Word.stats("mamamama", "ro").importance
+print(str(Word.stats("maman", "fr")))
+print(str(Word.stats("Mutter", "de")))
+print(str(Word.stats("Mother", "en")))
+print(str(Word.stats("mamamama", "ro").importance))

portability/getchunix.py

@@ -0,0 +1,120 @@
+import sys
+
+class _Getch:
+    """Gets a single character from standard input."""
+    def __init__(self):
+        try:
+            self.impl = _GetchWindows()
+        except ImportError:
+            self.impl = _GetchUnix()
+
+    def __call__(self):
+        return self.impl()
+
+
+class _GetchUnix:
+    def __init__(self):
+        import tty
+
+    def __call__(self):
+        import tty, termios
+        fd = sys.stdin.fileno()
+        old_settings = termios.tcgetattr(fd)
+        try:
+            tty.setraw(sys.stdin.fileno())
+            ch = sys.stdin.read(1)
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+        return ch
+
+
+class _GetchWindows:
+    def __init__(self):
+        import msvcrt
+
+    def __call__(self):
+        import msvcrt
+        return msvcrt.getch()
+
+
+parsenum = (lambda num:
+            (sys.maxsize if 0 > num else num))
+
+
+def read_single_keypress():
+    """interface for _Getch that interprets backspace and DEL properly"""
+    getch = _Getch()
+    x = getch.__call__()
+    ox = ord(x)
+    if ox == 27 or ox == 127:
+        sys.stdout.write(chr(8))
+        sys.stdout.write(chr(32))  # hacky? indeed. does it *work*? hell yeah!
+        sys.stdout.write(chr(8))
+
+    elif ox == 3: raise KeyboardInterrupt
+    elif ox == 4: raise EOFError
+    return x
+
+
+def nbsp(x, y):
+    """append x to y as long as x is not DEL or backspace"""
+    if ord(x) == 27 or ord(x) == 127:
+        try:
+            y.pop()
+        except IndexError:
+            pass
+        return y
+    y.append(x)
+    return y
+
+
+def thismany(count=-1) -> str:
+    """get exactly count chars of stdin"""
+    y = []
+    count = parsenum(count)
+    while len(y) <= count:
+        i = read_single_keypress()
+        _ = sys.stdout.write(i)
+        sys.stdout.flush()
+        y = nbsp(i, y)
+    return "".join(y)
+
+
+def until(chars, count=-1) -> str:
+    """get chars of stdin until any of chars is read,
+    or until count chars have been read, whichever comes first"""
+    y = []
+    chars = list(chars)
+    count = parsenum(count)
+    while len(y) <= count:
+        i = read_single_keypress()
+        _ = sys.stdout.write(i)
+        sys.stdout.flush()
+        if i in chars:
+            break
+        y = nbsp(i, y)
+    return "".join(y)
+
+
+def until_not(chars, count=-1) -> str:
+    """read stdin until any of chars stop being read,
+    or until count chars have been read; whichever comes first"""
+    y = []
+    chars = list(chars)
+    count = parsenum(count)
+    while len(y) <= count:
+        i = read_single_keypress()
+        _ = sys.stdout.write(i)
+        sys.stdout.flush()
+        if i not in chars:
+            break
+        y = nbsp(i, y)
+    return "".join(y)
+
+
+def pretty_press() -> str:
+    """literally just read any fancy char from stdin let caller do whatever"""
+    i = read_single_keypress()
+    _ = sys.stdout.write(i)
+    sys.stdout.flush()
+    return nbsp(i, y)

setup.py

@@ -31,6 +31,9 @@ def package_files(directory):
     description="Python Class for Word Statistics ",
     keywords="second language acquisition api",
     package_data={'': extra_files},
+    dependency_links=[
+        "https://github.com/zeeguu-ecosystem/Python-Translators/tarball/master#egg=python_translators"],
     install_requires=("configobj",
-                      "sqlalchemy")
+                      "sqlalchemy",
+                      'python_translators')
 )

wordstats/__init__.py

@@ -6,6 +6,10 @@
 # them when it does the reflection thing to create the DB tables
 from .word_info import WordInfo
 from .language_info import LanguageInfo
+from .edit_distance_function_factory import WordDistance
+from .translate_db import TranslationDatabase
+from .cognate_db import CognateDatabase
+
 
 # Create all tables in the engine. equivalent to "Create Table" in SQL
 Base.metadata.create_all(BaseService.engine)

wordstats/cognate_db.py

@@ -0,0 +1,67 @@
+from sys import stdout
+
+import sqlalchemy.orm
+import sqlalchemy
+from sqlalchemy import Column, Integer, String, UniqueConstraint, Boolean
+
+from .base_service import Base, SimplifiedQuery
+
+# structure for reviewed cognates
+class CognateDatabase(SimplifiedQuery, Base):
+    __tablename__ = 'cognate_database'
+    __table_args__ = {'mysql_collate': 'utf8_bin'}
+
+    id = Column(Integer, primary_key=True)
+
+    word_primary = Column(String(255), nullable =False, index = True)
+    word_secondary = Column(String(255), nullable=False, index=True)
+    primary = Column(String(20), nullable =False, index = True)
+    secondary = Column(String(20), nullable=False, index=True)
+    author = Column(String(255), nullable=False, index=True)
+    whitelist = Column(Boolean)
+
+    UniqueConstraint(word_primary, word_secondary, primary, secondary, author)
+
+    def __init__(self, word_primary, word_secondary, primary, secondary, whitelist, author: str = ""):
+        self.word_primary = word_primary
+        self.word_secondary = word_secondary
+        self.primary = primary
+        self.secondary = secondary
+        self.whitelist = whitelist
+        self.author = author
+
+    def __str__(self):
+        result = "info: {2} ({0} {1}, whitelist: {3}, author: {4})".format(
+            self.word_primary,
+            self.word_secondary,
+            self.primary + self.secondary,
+            self.whitelist,
+            self.author)
+
+        result = result.encode(stdout.encoding)
+        return result
+
+    @classmethod
+    def find(cls, word, primary, secondary, author: str = ""):
+        word = word.lower()
+        try:
+            return (cls.query().filter(cls.word_primary == word).\
+                    filter(cls.primary == primary).\
+                    filter(cls.secondary == secondary). \
+                    filter(cls.author == author). \
+                    one())
+        except sqlalchemy.orm.exc.NoResultFound:
+            return None
+
+    @classmethod
+    def find_all(cls, primary, secondary, author: str = ""):
+        return cls.query().filter(cls.primary == primary).\
+            filter(cls.secondary == secondary). \
+            filter(cls.author == author). \
+            all()
+
+    @classmethod
+    def clear_entries(cls, primary, secondary, author: str = ""):
+        cls.query().filter(cls.primary == primary). \
+            filter(cls.secondary == secondary).filter(cls.author == author).\
+            delete(synchronize_session=False)