cyg 0.0.dev1__tar.gz

cyg-0.0.dev1/LICENSE

@@ -0,0 +1,9 @@
+
+
+Copyright (c) 2026 CultureLab
+
+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 (including the next paragraph) 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.

cyg-0.0.dev1/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.5
+Name: cyg
+Version: 0.0.dev1
+Summary: A package to query Cygnet, a reformulation of the Open Multilingual Wordnet
+Project-URL: Homepage, https://github.com/smpouli/cygnet_python_package
+Project-URL: Documentation, https://github.com/smpouli/cygnet_python_package/blob/main/documentation.txt
+Project-URL: Repository, https://github.com/smpouli/cygnet_python_package
+License-Expression: MIT
+License-File: LICENSE
+Keywords: Wordnet,language,linguistics,multilingual
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Text Processing
+Requires-Python: >=3.9
+Requires-Dist: urllib3
+Description-Content-Type: text/markdown
+
+# Product Name
+>Cyg is a Python library conceived to query Cygnet, a reformulation of the Open Multilingual WordNet.
+
+
+Cyg makes it possible to return ilis of concepts in different languages and also to compare senses, definitions and relationships between concepts. The database can also be queried online: https://cygnet.maudslay.eu/.
+
+
+
+## Release History
+ 0.0.1b1
+    * Work in progress
+
+## Meta
+
+Distributed under the MIT license. See ``LICENSE`` for more information.
+
+[https://github.com/smpouli/cygnet_python_package]
+
+
+

cyg-0.0.dev1/README.md

@@ -0,0 +1,20 @@
+# Product Name
+>Cyg is a Python library conceived to query Cygnet, a reformulation of the Open Multilingual WordNet.
+
+
+Cyg makes it possible to return ilis of concepts in different languages and also to compare senses, definitions and relationships between concepts. The database can also be queried online: https://cygnet.maudslay.eu/.
+
+
+
+## Release History
+ 0.0.1b1
+    * Work in progress
+
+## Meta
+
+Distributed under the MIT license. See ``LICENSE`` for more information.
+
+[https://github.com/smpouli/cygnet_python_package]
+
+
+

cyg-0.0.dev1/documentation.txt

@@ -0,0 +1,199 @@
+
+First step:
+
+import cygnet
+
+
+Use cases
+
+1/ Count all concepts 
+
+c = cygnet.Cygnet().concepts()
+print (len(c)) 
+
+* Filter by POS only
+
+c = cygnet.Cygnet().concepts(pos="noun")
+
+Note: only four POS currently present (noun, verb, adj and adv) in the table used
+
+* Filter by language(s)
+
+c = cygnet.Cygnet().concepts(langs="it")
+
+c = cygnet.Cygnet().concepts(pos="adv", langs="it")
+
+* Filter by  by form
+
+c = cygnet.Cygnet().concepts(form="bal")
+
+c = cygnet.Cygnet().concepts(form="bal", pos="noun", langs="fr")
+
+
+
+
+2/ Working with concepts
+
+=> find the POS and index of a concept
+for a in c:
+	print (a.pos())
+
+=> find the index of a concept
+for a in c:
+	print (a.index())
+
+=> find the definition of a concept
+# the offset is not implemented because the data is lacking
+for a in c:
+	f = a.definition("es")
+	print (f.text())
+
+
+=> find semantically related concepts:
+
+c =cygnet.Cygnet().concepts(form="cheek", langs="en")
+for a in c:
+    rel=a.holonyms()
+
+Available relationships:
+- hypernymy: a.hypernyms()
+- hyponyny: a.hyponyms()
+- meronymy: a.meronyms ()
+- holonyms: a.holonyms()
+
+=> Retrieve senses from concepts:
+
+c =cygnet.Cygnet().concepts(form="cheek", langs="en")
+for a in c:
+    senses=a.senses("en")
+    print (a, senses)
+
+
+=> Retrieve lexemes from concepts: 
+
+
+c =cygnet.Cygnet().concepts(form="cheek", langs="en")
+for a in c:
+    words=a.lexemes("en")
+    print (a, words)
+
+
+3/ Count all lexemes
+
+c = cygnet.Cygnet().lexemes()
+print (len(c))
+
+
+* Filter by form
+
+c = cygnet.Cygnet().lexemes(form="but")
+print (c)
+
+* Filter from language(s)
+
+c = cygnet.Cygnet().lexemes(form="but", langs=["en", "fr"])
+
+print (c)
+
+
+	
+4/ Working with lexemes
+
+=> find the index of the lexeme
+
+c =cygnet.Cygnet().concepts(form="cheek", langs="en")
+for a in c:
+    words=a.lexemes()
+    for w in words:
+        print (w.index())
+
+=> find the language of the lexeme:
+c =cygnet.Cygnet().concepts(form="sudden", langs="en")
+print (c)
+for a in c:
+    words=a.lexemes()
+    for w in words:
+        print (w.lang())
+		
+
+=> find the lemma	
+c =cygnet.Cygnet().concepts(form="been")
+for a in c:
+    words=a.lexemes("en")
+    for w in words:
+        print (w.lemma())
+
+
+=> print all forms of the lemma:
+c =cygnet.Cygnet().concepts(form="been")
+for a in c:
+    words=a.lexemes("en")
+    for w in words:
+        print (w.all_forms())
+		
+
+=> find the concepts related to the lexeme
+
+c =cygnet.Cygnet().concepts(form="pray")
+for a in c:
+    words=a.lexemes("en")
+    for w in words:
+        print (w.concepts())
+		
+
+=> find the senses related to the lexeme
+c =cygnet.Cygnet().concepts(form="pray")
+for a in c:
+    words=a.lexemes("en")
+    for w in words:
+        print (w.senses())
+
+5/ Count all senses
+
+c = cygnet.Cygnet().senses()
+print (len(c))
+
+* Filter by form
+
+c = cygnet.Cygnet().senses(form="chaos")
+print (c)
+
+* Filter from language(s)
+
+c = cygnet.Cygnet().senses(form="chaos", langs=["en", "fr"])
+print (c)
+
+
+6/ Working with senses
+
+=> find the index of the sense
+
+c = cygnet.Cygnet().senses(form="chaos", langs=["en", "fr"])
+
+for b in c:
+    print (b, b.index())
+	
+	
+	
+=> find the concepts related to the sense
+c = cygnet.Cygnet().senses(form="chaos", langs=["en"])
+
+for b in c:
+    print (b, b.concept())
+	
+
+=> find the lexeme related to the sense:
+
+c = cygnet.Cygnet().senses(form="chaos")
+
+for b in c:
+    print (b, b.lexeme(), b.lang())
+
+=> display examples of the sense and offsets
+
+c =cygnet.Cygnet().concepts(form="sordid")
+for a in c:
+    words=a.lexemes("en")
+    for w in words:
+        for d in w.senses():
+            print (d, d.examples().text(), d.examples().sense_offsets())

cyg-0.0.dev1/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/cyg"]
+sources = ["src/cyg"]
+
+
+[project]
+name = "cyg"
+version = "0.0.dev1"
+description = "A package to query Cygnet, a reformulation of the Open Multilingual Wordnet"
+keywords = ["Wordnet", "multilingual", "linguistics", "language"]
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "urllib3",
+]
+classifiers = [       
+    "Programming Language :: Python :: 3",   
+    "Operating System :: OS Independent",
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers", 
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Text Processing",
+    "Topic :: Database",
+    "Topic :: Scientific/Engineering :: Information Analysis"
+]
+
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://github.com/smpouli/cygnet_python_package"
+Documentation = "https://github.com/smpouli/cygnet_python_package/blob/main/documentation.txt"
+Repository = "https://github.com/smpouli/cygnet_python_package"

cyg-0.0.dev1/src/cyg/api.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import List, Tuple, Literal, Optional
+
+POS = Literal["noun", "verb", "adj", "adv", "adp", "unk", "conj", "nref"]
+
+class Cygnet(ABC):
+    """Top-level access point for querying the Cygnet database."""
+
+    @abstractmethod
+    def concepts(self,
+                form: Optional[str] = None,
+                langs: List[str] | str | None = None,
+                pos : Optional[POS] = None
+                ) -> List[AbstractConcept]:
+        """Returns all concepts, optionally filtered by wordform, language(s), and/or part of speech."""
+        pass
+
+    @abstractmethod
+    def concept(self,
+                ili: str
+                ) -> Optional[AbstractConcept]:
+        """Returns the concept identified by the given ILI (Interlingual Index) string, or None if not found."""
+        pass
+
+    @abstractmethod
+    def senses(self,
+               form: Optional[str] = None,
+               langs: List[str] | str | None = None
+               ) -> List[AbstractSense]:
+        """Returns all senses, optionally filtered by wordform and/or language(s)."""
+        pass
+
+    @abstractmethod
+    def lexemes(self,
+                form: Optional[str] = None,
+                langs: List[str] | str | None = None
+                ) -> List[AbstractLexeme]:
+        """Returns all lexemes, optionally filtered by wordform and/or language(s)."""
+        pass
+
+    @abstractmethod
+    def langs(self) -> List[str]:
+        """Returns the list of language codes available in the database."""
+        pass
+
+class AbstractConcept(ABC):
+    """A language-independent concept, corresponding to a synset in traditional Wordnet releases."""
+
+    @abstractmethod
+    def definition(self,
+                   lang: str = "en"
+                   ) -> Optional[AbstractAnnotatedString]:
+        """Returns the definition of this concept in the given language, or None if unavailable."""
+        pass
+
+    @abstractmethod
+    def pos(self) -> POS:
+        """Returns the part of speech (ontological category) of this concept."""
+        pass
+
+    @abstractmethod
+    def index(self) -> str:
+        """Returns the unique identifier (ILI) for this concept."""
+        pass
+
+    @abstractmethod
+    def senses(self,
+               lang: Optional[str] = None
+               ) -> List[AbstractSense]:
+        """Returns all senses linked to this concept, optionally filtered by language."""
+        pass
+
+    @abstractmethod
+    def lexemes(self,
+                lang: Optional[str] = None
+                ) -> List[AbstractLexeme]:
+        """Returns all lexemes linked to senses of this concept, optionally filtered by language."""
+        pass
+
+    @abstractmethod
+    def hypernyms(self) -> List[AbstractConcept]:
+        """Returns concepts that are connected to this concept by a hypernym relation."""
+        pass
+
+    @abstractmethod
+    def hyponyms(self) -> List[AbstractConcept]:
+        """Returns concepts that are connected to this concept by a hyponymy relation."""
+        pass
+
+    @abstractmethod
+    def meronyms(self) -> List[AbstractConcept]:
+        """Returns concepts that are connected to this concept by a meronymy relation."""
+        pass
+
+    @abstractmethod
+    def holonyms(self) -> List[AbstractConcept]:
+        """Returns concepts that are connected to this concept by a holonymy relation."""
+        pass
+
+class AbstractSense(ABC):
+    """A pairing of a lexeme with a concept, representing one meaning of a word."""
+
+    @abstractmethod
+    def index(self) -> str:
+        """Returns the unique identifier for this sense."""
+        pass
+
+    @abstractmethod
+    def examples(self) -> List[AbstractAnnotatedString]:
+        """Returns usage examples illustrating this sense."""
+        pass
+
+    @abstractmethod
+    def concept(self) -> AbstractConcept:
+        """Returns the concept associated with this sense (the signified)."""
+        pass
+
+    @abstractmethod
+    def lexeme(self) -> AbstractLexeme:
+        """Returns the lexeme associated with this sense (the signifier)."""
+        pass
+
+    @abstractmethod
+    def lang(self) -> str:
+        """Returns the language code of this sense's lexeme."""
+        pass
+
+class AbstractLexeme(ABC):
+    """A wordform in a specific language, with all possible inflections."""
+
+    @abstractmethod
+    def index(self) -> str:
+        """Returns the unique identifier for this lexeme."""
+        pass
+
+    @abstractmethod
+    def lang(self) -> str:
+        """Returns the language code of this lexeme."""
+        pass
+
+    @abstractmethod
+    def lemma(self) -> str:
+        """Returns the canonical form of this lexeme."""
+        pass
+
+    @abstractmethod
+    def all_forms(self) -> List[str]:
+        """Returns all inflected forms of this lexeme (including the lemma)."""
+        pass
+
+    @abstractmethod
+    def senses(self) -> List[AbstractSense]:
+        """Returns every sense that references this lexeme."""
+        pass
+
+    @abstractmethod
+    def concepts(self) -> List[AbstractConcept]:
+        """Returns every concept linked to this lexeme via a sense."""
+        pass
+
+class AbstractAnnotatedString(ABC):
+    """A string of text with sense annotations."""
+
+    @abstractmethod
+    def text(self) -> str:
+        """Return the plain text content of this string."""
+        pass
+
+    @abstractmethod
+    def lang(self) -> str:
+        """Return the language code of the language this string is in."""
+        pass
+
+    @abstractmethod
+    def sense_offsets(self) -> List[Tuple[AbstractSense, int, int]]:
+        """Return a list of (sense, start, end) tuples marking annotated spans within the text."""
+        pass

cyg-0.0.dev1/src/cyg/cygnet.py

@@ -0,0 +1,47 @@
+from typing import List, Optional
+import queries
+from api import AbstractConcept, AbstractSense, AbstractLexeme, POS
+from subclasses import*
+
+
+class Cygnet:
+    """
+    main class of the module
+    """
+    def __init__(self):
+       pass
+
+    def concepts(self,
+                 form: Optional[str] = None,
+                 langs=None,
+                 pos: Optional[POS] = None
+                 ) -> List[AbstractConcept]:
+        rows = queries.fetch_concepts(form=form, langs=langs, pos=pos)
+        return [Concept(row) for row in rows]
+
+    def concept(self, ili: str) -> Optional[AbstractConcept]:
+        row = queries.fetch_concept_by_ili(ili)
+        if row is None:
+            return None
+        else:
+            return Concept(row)
+        
+    def senses(self,
+               form: Optional[str] = None,
+               langs=None
+               ) -> List[AbstractSense]:
+        rows = queries.fetch_senses(form=form, langs=langs)
+        return [Sense(row) for row in rows]
+
+    def lexemes(self,
+                form: Optional[str] = None,
+                langs=None
+                ) -> List[AbstractLexeme]:
+        rows = queries.fetch_lexemes(form=form, langs=langs)
+        return [Lexeme(row) for row in rows]
+    
+
+    def langs(self) -> List[str]:
+        languages = queries.print_all_languages()
+        return [l[0] for l in languages]
+    

cyg-0.0.dev1/src/cyg/data/help.txt

@@ -0,0 +1,4 @@
+If for whatever reason, the database cannot be downloaded automatically:
+
+2- Download the database here:https://github.com/rowanhm/cygnet/releases/latest/download/cygnet.db.gz
+3- Unzip it and store it in this folder.

cyg-0.0.dev1/src/cyg/db.py

@@ -0,0 +1,43 @@
+
+from pathlib import Path
+import urllib.request
+import os, gzip, shutil
+import sqlite3
+
+# database checking and downloading
+path_to_installed_database=Path('src/cyg/data/cygnet.db')
+
+if path_to_installed_database.exists():   
+    # connexion to the database
+    conn = sqlite3.connect('src/cyg/data/cygnet.db')
+    Database = conn.cursor()
+else:    
+    download_url = "https://github.com/rowanhm/cygnet/releases/latest/download/cygnet.db.gz"
+    
+    gz_file = Path("src/cyg/data/cygnet.db.gz")
+    output_file = Path("src/cyg/data/cygnet.db")
+  
+    
+    try:
+        # Download
+        print ("The Cygnet database needs to be downloaded. This will happen only once.")
+        print ("Downloading Cygnet database...")
+        urllib.request.urlretrieve(download_url, gz_file)
+        print ("Cygnet database successfully downloaded.")
+        # Decompress
+        with gzip.open(gz_file, "rb") as gz:
+            with open(output_file, "wb") as output:
+                shutil.copyfileobj(gz, output)
+
+        os.remove(gz_file)
+        print("Cygnet database successfully extracted and stored.")
+        
+        # connexion to the database
+        conn = sqlite3.connect('src/cyg/data/cygnet.db')
+        Database = conn.cursor()
+    except:
+        print ("An error occurred, please try again or look at the help file in the data folder.")
+
+       
+
+    

cyg-0.0.dev1/src/cyg/queries.py

@@ -0,0 +1,284 @@
+from typing import Optional
+from db import Database
+
+
+#-------- queries related to cygnet.py
+
+def fetch_concepts(form: Optional[str] = None,
+                   langs=None,
+                   pos: Optional[str] = None):
+    """
+    Retrieve all concepts optionally filtered by form, languages and/or POS
+    """
+    sql_concept = """SELECT DISTINCT synsets.rowid, LOWER(synsets.pos), ili FROM synsets
+                    JOIN senses ON synsets.rowid = senses.synset_rowid
+                    JOIN entries ON entries.rowid = senses.entry_rowid
+                    JOIN forms ON entries.rowid = forms.entry_rowid
+                    JOIN languages ON languages.rowid = entries.language_rowid"""
+    params: list = []
+    conditions = []
+    if form:
+        conditions.append(" form=?")
+        params += [form]
+    if langs:
+        lang_list = [langs] if isinstance(langs, str) else langs
+        placeholders = ",".join("?" * len(lang_list))
+        conditions.append(f" languages.code IN ({placeholders})")
+        params += lang_list
+    if pos:
+        conditions.append(" LOWER(synsets.pos)=?")
+        params.append(pos)
+
+    if len(conditions)==1:
+        sql_concept=  sql_concept + "\n WHERE  " + conditions[0] + "\n ORDER BY synsets.rowid ASC"
+     
+    elif len(conditions)>1:
+        condition = "\n WHERE " + " AND ".join(conditions)
+        sql_concept +=f""" {condition}
+                    ORDER BY synsets.rowid ASC"""  
+    
+    return Database.execute(sql_concept, tuple(params)).fetchall()
+
+
+
+
+
+def fetch_concept_by_ili ( ili: str):
+    """
+    Retrieve the specific concept related to an ILI
+    """
+    return Database.execute(
+        """SELECT rowid, LOWER(pos), ili FROM synsets        
+      WHERE ili=?""", (ili,)
+    ).fetchone()
+
+
+def fetch_senses(form: Optional[str] = None, langs=None):
+    """
+    Retrieve all concepts optionnally filtered by form and/or languages
+    """
+    sql_sense= "SELECT DISTINCT senses.rowid, senses.synset_rowid, senses.entry_rowid FROM senses"
+    params: list = []
+    conditions = []
+    if form:
+        conditions.append(" form=?")
+        params += [form]
+    if langs:
+        lang_list = [langs] if isinstance(langs, str) else langs
+        placeholders = ",".join("?" * len(lang_list))
+        conditions.append(f" languages.code IN ({placeholders})")
+        params += lang_list
+    
+    if len(conditions)==1:
+        sql_sense +=  """ \n JOIN entries ON entries.rowid = senses.entry_rowid
+                    JOIN forms ON entries.rowid = forms.entry_rowid
+                    JOIN languages ON languages.rowid = entries.language_rowid""" + "\n WHERE  " + conditions[0] + """\n ORDER BY senses.sense_index, senses.rowid"""
+     
+    elif len(conditions)>1:
+        condition = "\n WHERE " + " AND ".join(conditions)
+        sql_sense +=f""" \n JOIN entries ON entries.rowid = senses.entry_rowid
+                    JOIN forms ON entries.rowid = forms.entry_rowid
+                    JOIN languages ON languages.rowid = entries.language_rowid
+                    {condition}
+                    ORDER BY senses.sense_index, senses.rowid"""
+  
+    
+    return Database.execute(sql_sense, tuple(params)).fetchall()
+
+
+
+
+def fetch_lexemes(form: Optional[str] = None, langs=None):
+    """
+    Retrieve all lexemes optionnally filtered by form and/or languages
+    """
+    sql_lexeme= "SELECT DISTINCT entries.rowid from entries"
+    params: list = []
+    conditions = []
+    if form:
+        conditions.append(" form=?")
+        params += [form]
+    if langs:
+        lang_list = [langs] if isinstance(langs, str) else langs
+        placeholders = ",".join("?" * len(lang_list))
+        conditions.append(f" languages.code IN ({placeholders})")
+        params += lang_list
+    
+    if len(conditions)==1:
+        sql_lexeme +=  """ \n JOIN senses ON entries.rowid = senses.entry_rowid
+                                JOIN forms ON entries.rowid = forms.entry_rowid
+                    JOIN languages ON languages.rowid = entries.language_rowid""" + "\n WHERE  " + conditions[0] + """\n ORDER BY entries.rowid ASC"""
+     
+    elif len(conditions)>1:
+        condition = "\n WHERE " + " AND ".join(conditions)
+        sql_lexeme +=f""" \n JOIN forms ON entries.rowid = forms.entry_rowid
+                    JOIN languages ON languages.rowid = entries.language_rowid
+                    {condition}
+                    ORDER BY entries.rowid ASC"""
+  
+    
+    return Database.execute(sql_lexeme, tuple(params)).fetchall()
+
+
+def print_all_languages ():
+    """
+    Display the codes of all languages available in the database
+    """
+    return Database.execute("""SELECT code FROM languages ORDER BY code""" ).fetchall()
+
+
+#-------- queries related to the class concept
+
+
+def fetch_definition(rowid, lang: str):       
+    """
+    Retrieve the definition of a concept in a given language
+    """
+    sql_def = """SELECT definitions.definition, languages.code FROM definitions
+                JOIN languages ON languages.rowid=definitions.language_rowid
+                WHERE definitions.synset_rowid=? AND languages.code=?""" 
+    
+   
+    return Database.execute(sql_def, (rowid, lang)).fetchone()
+
+
+def fetch_senses_by_concept(rowid,lang: Optional[str] = None):
+    """
+    Retrieve the senses of a concept optionally filtered by language
+    """
+    sql_senses_concept=""" SELECT DISTINCT senses.rowid, senses.synset_rowid, senses.entry_rowid FROM senses"""
+    params=[rowid]
+                         
+    if lang:
+        sql_senses_concept += """\n JOIN entries ON entries.rowid=senses.entry_rowid 
+                                     JOIN languages on entries.language_rowid=languages.rowid
+                                     WHERE synset_rowid = ? AND languages.code=?
+                                    ORDER BY senses.sense_index, senses.rowid"""
+        params.append(lang)
+    else:
+        sql_senses_concept += """ \n WHERE synset_rowid = ?
+                                    ORDER BY senses.sense_index, senses.rowid"""
+        
+    return Database.execute(sql_senses_concept, tuple(params)).fetchall()
+
+
+
+
+def fetch_lexemes_by_concept(rowid,lang: Optional[str] = None):
+    """
+    Retrieve the lexemes related to a concept optionally filtered by language
+    """
+    sql_lexemes_concept=""" SELECT DISTINCT senses.entry_rowid FROM senses"""
+    params=[rowid]
+                         
+    if lang:
+        sql_lexemes_concept += """\n JOIN entries ON entries.rowid=senses.entry_rowid 
+                                     JOIN languages on entries.language_rowid=languages.rowid
+                                     WHERE senses.synset_rowid = ? AND languages.code=? 
+                                     ORDER BY senses.entry_rowid ASC"""
+        params.append(lang)
+    else:
+        sql_lexemes_concept += """ \n WHERE senses.synset_rowid = ?
+                                    ORDER BY senses.entry_rowid ASC"""
+        
+    return Database.execute(sql_lexemes_concept, tuple(params)).fetchall()
+
+
+
+
+def fetch_related_synsets(rowid,relation):
+    """
+    Retrieve the hyperonyms, hyponyms, meronyms or holonyms of a concept
+    """
+    sql_rel="""SELECT target_rowid, LOWER(synsets.pos), synsets.ili  FROM synset_relations
+            JOIN synsets ON target_rowid=synsets.rowid
+            WHERE source_rowid=? AND type_rowid=?
+            ORDER BY target_rowid ASC"""
+    
+    return Database.execute(sql_rel, (rowid,relation)).fetchall()
+   
+  
+
+
+#-------- queries related to the class Sense
+
+def fetch_examples(sense_rowid):
+    """
+    Retrieve all examples of a particular sense
+    """
+    sql_examples = """ SELECT example, languages.code, example_annotations.sense_rowid, senses.synset_rowid, senses.entry_rowid, example_annotations.start_offset, example_annotations.end_offset FROM examples
+                    JOIN sense_examples ON examples.rowid= sense_examples.example_rowid
+                    JOIN example_annotations ON example_annotations.rowid=examples.rowid
+                    JOIN senses ON senses.rowid=sense_examples.sense_rowid 
+                    JOIN entries ON entries.rowid=senses.entry_rowid 
+                    JOIN languages on entries.language_rowid=languages.rowid 
+                    WHERE sense_examples.sense_rowid = ?
+                    ORDER BY example ASC"""
+    return Database.execute(sql_examples, (sense_rowid, )).fetchall()
+
+
+
+def fetch_concept_by_sense(sense_rowid):
+    """
+    Retrieve the concept related to a sense
+    """
+    sql_sense_concept=""" SELECT rowid, LOWER(pos), ili FROM synsets                  
+                    WHERE rowid = ?"""
+    return Database.execute(sql_sense_concept, (sense_rowid, )).fetchone()
+
+
+#-------- queries related to the class Lexeme
+
+
+def find_language_lexeme (lex_rowid):
+    """
+    Retrieve the language of a lexeme
+    """
+    sql_lex_lang=""" SELECT code FROM languages     
+                    JOIN entries ON entries.language_rowid = languages.rowid              
+                    WHERE entries.rowid = ?"""
+    return Database.execute(sql_lex_lang, (lex_rowid, )).fetchone()
+
+
+def find_lemma(lex_rowid):
+    """
+    Retrieve the lemma of a lexeme
+    """
+    sql_lex_lemma=""" SELECT normalized_form FROM forms
+                     WHERE rank=0 and entry_rowid= ?"""
+    return Database.execute(sql_lex_lemma, (lex_rowid, )).fetchone()
+
+
+def fetch_forms_by_lexeme(lex_rowid):
+    """
+    Retrieve all the forms of a lexeme
+    """
+    sql_lex_forms=""" SELECT form, entry_rowid, rank FROM forms
+                     WHERE entry_rowid= ?
+                     ORDER BY form ASC"""
+    return Database.execute(sql_lex_forms, (lex_rowid, )).fetchall()
+
+
+def fetch_senses_by_lexeme(lex_rowid):
+    """
+    Retrieve all the senses of a lexeme
+    """
+    sql_lex_senses="""SELECT rowid, synset_rowid, entry_rowid FROM senses
+                    WHERE entry_rowid= ?
+                    ORDER BY rowid ASC"""
+    return Database.execute(sql_lex_senses, (lex_rowid, )).fetchall()
+
+
+def fetch_concepts_by_lexeme(lex_rowid):
+    """
+    Retrieve all the concepts related to a lexeme
+    """
+    sql_lex_concepts="""SELECT synset_rowid, LOWER(synsets.pos), synsets.ili FROM senses
+                    JOIN synsets ON  synsets.rowid=senses.synset_rowid
+                    WHERE senses.entry_rowid= ?
+                    ORDER BY synsets.rowid ASC"""
+    return Database.execute(sql_lex_concepts, (lex_rowid, )).fetchall()
+
+
+
+

cyg-0.0.dev1/src/cyg/subclasses.py

@@ -0,0 +1,200 @@
+from typing import List, Optional,Tuple
+from api import AbstractConcept, AbstractSense, AbstractLexeme, POS, AbstractAnnotatedString
+import queries
+
+
+class Concept(AbstractConcept):   
+    """
+    Implementation of the object Concept
+    """
+    def __init__(self, data):              
+        self.integer= data[0]
+        self.gram_cat = data[1]
+        self.identifier= data[2]
+       
+       
+    def __repr__(self):
+        return "Concept(id="+ str(self.integer)+')'
+
+    def index(self) -> str:
+        return self.identifier
+
+    def pos(self) -> POS:
+        return self.gram_cat
+    
+    def definition(self, lang: str) -> Optional[AbstractAnnotatedString]:
+       row = queries.fetch_definition(self.integer, lang)
+       if row is None:
+            return None       
+       else:            
+            return AnnotatedString_Temp(row)
+
+    def senses(self, lang: Optional[str] = None) -> List[AbstractSense]:
+        rows= queries.fetch_senses_by_concept(self.integer,lang)
+        return [Sense(row) for row in rows]
+
+    def lexemes(self, lang: Optional[str] = None) -> List[AbstractLexeme]:
+       rows= queries.fetch_lexemes_by_concept(self.integer,lang)
+       return [Lexeme(row) for row in rows]
+
+    def hypernyms(self) -> List[AbstractConcept]:
+        rel_hyper= queries.fetch_related_synsets(self.integer,"5")
+        return [Concept(row) for row in rel_hyper]
+    
+    def hyponyms(self) -> List[AbstractConcept]: 
+        rel_hypo= queries.fetch_related_synsets(self.integer,"6")
+        return [Concept(row) for row in rel_hypo]
+    
+    def meronyms(self) -> List[AbstractConcept]:  
+       rel_mero=queries.fetch_related_synsets(self.integer,"7")
+       return [Concept(row) for row in rel_mero]
+    
+    def holonyms(self) -> List[AbstractConcept]: 
+        rel_holo=queries.fetch_related_synsets(self.integer,"8")
+        return [Concept(row) for row in rel_holo]
+    
+
+
+    
+
+class Lexeme(AbstractLexeme): 
+    """
+    Implementation of the object Lexeme
+    """
+    
+    def __init__(self, data):              
+        self.integer= data[0]
+
+    
+    def __repr__(self):
+        return "Lexeme(id="+ str(self.integer)+")"
+    
+    def index(self) -> str:
+         return str(self.integer)
+    
+    def lang(self) -> str:   
+       row = queries.find_language_lexeme (self.integer)
+       return (row[0])  
+  
+    def lemma(self) -> str:
+        row = queries.find_lemma (self.integer)
+        return (row[0])  
+   
+    def all_forms(self) -> List[str]:
+        rows = queries.fetch_forms_by_lexeme(self.integer)
+        results =[]
+        for row in rows:
+            results.append(row[0])
+        return results  
+   
+    def senses(self) -> List[AbstractSense]:       
+        rows = queries.fetch_senses_by_lexeme(self.integer)
+        return [Sense(row) for row in rows]     
+
+
+    def concepts(self) -> List[AbstractConcept]:
+        rows = queries.fetch_concepts_by_lexeme(self.integer)
+        return [Concept(row) for row in rows] 
+
+
+
+
+
+class Sense(AbstractSense): 
+    """
+    Implementation of the object Sense
+    """
+    def __init__(self, data):                
+        self.integer= data[0]
+        self.linked_concept = data[1]
+        self.linked_entry = data[2]
+     
+
+    def __repr__(self):
+        return "Sense(id="+ str(self.integer)+")"
+
+    def index(self) -> str:
+        return str(self.integer)
+    
+ 
+    def examples(self) -> List[AbstractAnnotatedString]:   
+        row = queries.fetch_examples(self.integer)
+        if row is None:
+            return None       
+        else:                   
+            return AnnotatedString(row)
+
+        
+    def concept(self) -> AbstractConcept:   
+        row = queries.fetch_concept_by_sense(self.linked_concept)
+        return Concept(row) 
+      
+
+    def lexeme(self) -> AbstractLexeme:      
+        return Lexeme([self.linked_entry])
+
+  
+    def lang(self) -> str:    
+       row = queries.find_language_lexeme (self.linked_entry)
+       return (row[0])  
+    
+
+
+
+class AnnotatedString_Temp(AbstractAnnotatedString):    
+    """
+    Temporary class to deal with definitions
+    """ 
+    def __init__(self, data):           
+        self._text = data[0]
+        self._lang = data[1]
+
+
+    def text(self) -> str:
+        return self._text
+
+    def lang(self) -> str:
+        return self._lang
+    
+    def sense_offsets(self) -> List[Tuple[AbstractSense, int, int]]:
+        pass
+
+
+class AnnotatedString(AbstractAnnotatedString):
+    """
+    Print examples and definitions as well as their annotations
+    """
+   
+    def __init__(self, data):     
+        
+        self._text=[]
+        self._lang=[] 
+        self._dic={}   
+        for elem in data:                 
+            self._lang = elem[1]
+            self._text.append(elem[0])
+            if  (elem[2], elem[3], elem[4]) not in self._dic:
+                self._dic[(elem[2], elem[3], elem[4])]=[[elem[-2], elem[-1]]]     
+            else:
+                 self._dic[(elem[2], elem[3], elem[4])].append([elem[-2], elem[-1]])
+                
+             
+
+    def text(self) -> str:
+        return self._text
+
+    def lang(self) -> str:
+        return self._lang
+
+    def sense_offsets(self) -> List[Tuple[AbstractSense, int, int]]:    
+    
+        list_offsets=[]
+        for sense_index in self._dic:
+            for list_numbers in self._dic[sense_index]:
+                list_offsets.append(tuple([Sense(sense_index), list_numbers[0],  list_numbers[1]]))
+
+        return list_offsets
+        
+     
+
+