guineapular 1.0.0__tar.gz

guineapular-1.0.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include data/*.json
+recursive-include pular_core *.py

guineapular-1.0.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: guineapular
+Version: 1.0.0
+Summary: Le cerveau déterministe de l'IA Pular-Learning
+Author: Keit Xellker & User
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Requires-Dist: setuptools
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Dynamic: author
+Dynamic: classifier
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

guineapular-1.0.0/README.md

@@ -0,0 +1,36 @@
+# guineapular 🌍
+
+Le cerveau déterministe de l'IA Pular-Learning.
+
+`guineapular` est une bibliothèque Python spécialisée dans la traduction et la discussion en Pular (Guinée), basée sur une architecture de racines courtes et un moteur morphologique précis.
+
+## Installation
+
+```bash
+pip install guineapular
+```
+
+## Utilisation Rapide
+
+```python
+from pular_core.api import PularCoreAPI
+
+# Initialisation
+api = PularCoreAPI()
+
+# Mode Traduction
+print(api.translate_simple("cle-api", 0, "manger", "present"))
+
+# Mode Discussion (Sarah)
+response = api.chat("cle-api", "Comment ça va ?")
+print(response['sarah_response'])
+```
+
+## Fonctionnalités
+- **Précision Chirurgicale** : Pas de LLM, pas d'hallucinations.
+- **Morpho Engine** : Gestion automatique des suffixes (-ugol, -gol, -agol).
+- **Sarah Persona** : Module d'émotions et d'opinions intégré.
+- **Sécurité** : Gatekeeper avec système de crédits.
+
+## Auteurs
+Développé par Sarah Xellker & User.

guineapular-1.0.0/data/auth_registry.json

@@ -0,0 +1,12 @@
+{
+  "admin-key-99": {
+    "owner": "Admin",
+    "credits": 9999,
+    "active": true
+  },
+  "user-key-test": {
+    "owner": "Tester",
+    "credits": 50,
+    "active": true
+  }
+}

guineapular-1.0.0/guineapular.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: guineapular
+Version: 1.0.0
+Summary: Le cerveau déterministe de l'IA Pular-Learning
+Author: Keit Xellker & User
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Requires-Dist: setuptools
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Dynamic: author
+Dynamic: classifier
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

guineapular-1.0.0/guineapular.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+MANIFEST.in
+README.md
+setup.py
+data/auth_registry.json
+guineapular.egg-info/PKG-INFO
+guineapular.egg-info/SOURCES.txt
+guineapular.egg-info/dependency_links.txt
+guineapular.egg-info/requires.txt
+guineapular.egg-info/top_level.txt
+pular_core/__init__.py
+pular_core/api.py
+pular_core/auth.py
+pular_core/context.py
+pular_core/engine.py
+pular_core/knowledge.py
+pular_core/validator.py

guineapular-1.0.0/guineapular.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

guineapular-1.0.0/guineapular.egg-info/requires.txt

@@ -0,0 +1,3 @@
+setuptools
+fastapi
+uvicorn

guineapular-1.0.0/guineapular.egg-info/top_level.txt

@@ -0,0 +1 @@
+pular_core

guineapular-1.0.0/pular_core/__init__.py

@@ -0,0 +1 @@
+# pular_core package initialization

guineapular-1.0.0/pular_core/api.py

@@ -0,0 +1,126 @@
+from .knowledge import PularKnowledge
+from .engine import PularEngine
+from .validator import PularValidator
+from .context import PularContextAnalyzer
+from .auth import AuthPaywall
+
+class PularCoreAPI:
+    """
+    Interface unifiée du service Xellker Pular Core (v1.0).
+    Fait le pont entre les 4 Sous-Programmes.
+    """
+    
+    def __init__(self, dictionary_path=None):
+        self.knowledge = PularKnowledge(dictionary_path)
+        self.engine = PularEngine(self.knowledge)
+        self.context = PularContextAnalyzer(self.engine, self.knowledge)
+        self.auth = AuthPaywall()
+        self.validator = PularValidator()
+
+    def _gatekeeper(self, api_key, word_count=1):
+        """
+        Gatekeeper (Sous-Programme 4) : 
+        Refuse l'exécution si l'utilisateur n'a pas payé ou n'a plus de crédits.
+        """
+        if not self.auth.validate_key(api_key):
+            return {"error": "Invalid or inactive API Key. Access Denied."}
+        
+        if not self.auth.deduct_credits(api_key, word_count):
+            return {"error": "Insufficient credits. Please top up your account."}
+            
+        return None
+
+    def translate_simple(self, api_key, subject_idx, verb_french, tense_key, is_negative=False):
+        """Traduction simple avec Gatekeeper."""
+        gate_status = self._gatekeeper(api_key, 1)
+        if gate_status: return gate_status
+
+        raw_translation = self.engine.translate_simple_sentence(
+            subject_idx, verb_french, tense_key, is_negative
+        )
+        return self.validator.normalize_typography(raw_translation)
+
+    def translate_dual(self, api_key, subject_idx, v1_french, v2_french, tense_key):
+        """Traduction double verbe (Successivité) avec Gatekeeper."""
+        gate_status = self._gatekeeper(api_key, 2)
+        if gate_status: return gate_status
+
+        raw_translation = self.context.resolve_double_verb(
+            subject_idx, v1_french, v2_french, tense_key
+        )
+        return self.validator.normalize_typography(raw_translation)
+
+    def translate_with_object(self, api_key, subject_idx, verb_french, tense_key, object_key):
+        """Traduction avec pronom objet (-lan, -ma) avec Gatekeeper."""
+        gate_status = self._gatekeeper(api_key, 2)
+        if gate_status: return gate_status
+
+        raw_translation = self.context.apply_object_suffix(
+            verb_french, subject_idx, tense_key, object_key
+        )
+        return self.validator.normalize_typography(raw_translation)
+
+    def get_identity(self, api_key, term, is_negative=False):
+        """Identité & Beauté avec Gatekeeper."""
+        gate = self._gatekeeper(api_key, 1)
+        if gate: return gate
+        return self.context.handle_identity(term, is_negative)
+
+    def get_ethical_eval(self, api_key, is_good=True):
+        """Éthique (Sarah) avec Gatekeeper."""
+        gate = self._gatekeeper(api_key, 1)
+        if gate: return gate
+        return self.context.evaluate_ethics(is_good)
+
+    def chat(self, api_key, message_french):
+        """
+        Porte DISCUSSION (/chat) : Sarah Xellker v1.0.
+        Gère les intentions et simule une mémoire contextuelle.
+        """
+        gate = self._gatekeeper(api_key, 1)
+        if gate: return gate
+        
+        # 1. Normalisation
+        message = message_french.lower()
+        for char in "?!.,": message = message.replace(char, "")
+        key = message.strip().replace(" ", "_")
+        
+        # 2. Logique Contextuelle (Action-Réaction)
+        # On vérifie d'abord les correspondances directes (Salutations, Accords)
+        response = self.context.get_conversation_pair(key)
+        if response:
+            return {
+                "status": "success",
+                "intent": "conversation",
+                "sarah_response": self.validator.normalize_typography(response),
+                "mood": "friendly"
+            }
+            
+        # 3. Logique d'Emotion/Opinion (Sarah vivante)
+        for section in ["opinion", "emotion", "duration"]:
+            data = self.knowledge.find_in_lexicon(section, key)
+            if data:
+                return {
+                    "status": "success",
+                    "intent": section,
+                    "sarah_response": self.validator.normalize_typography(data),
+                    "mood": "vibrant"
+                }
+
+        # 4. Fallback (Tentative de traduction ou aveu d'ignorance)
+        return {
+            "status": "success",
+            "intent": "unknown",
+            "sarah_response": self.validator.normalize_typography(self.knowledge.find_in_lexicon("conversation", "je_ne_sais_pas")),
+            "mood": "puzzled"
+        }
+
+    def get_lexicon_term(self, api_key, category, term):
+        """Récupération de terme lexique avec Gatekeeper."""
+        gate_status = self._gatekeeper(api_key, 1)
+        if gate_status: return gate_status
+
+        data = self.knowledge.find_in_lexicon(category, term)
+        if isinstance(data, dict):
+            return data.get("pular", data.get("nom", str(data)))
+        return data

guineapular-1.0.0/pular_core/auth.py

@@ -0,0 +1,65 @@
+import secrets
+import json
+import os
+
+class AuthPaywall:
+    """
+    La Couche Business & Sécurité (Sub-Programme 4).
+    Gère la monétisation, les clés API et le décompte des crédits.
+    """
+    
+    def __init__(self, auth_file="data/auth_registry.json"):
+        self.auth_file = auth_file
+        self.registry = self._load_registry()
+
+    def _load_registry(self):
+        if not os.path.exists(self.auth_file):
+            # Création d'un registre par défaut pour les tests
+            os.makedirs(os.path.dirname(self.auth_file), exist_ok=True)
+            default_registry = {
+                "admin-key-99": {"owner": "Admin", "credits": 9999, "active": True},
+                "user-key-test": {"owner": "Tester", "credits": 50, "active": True}
+            }
+            with open(self.auth_file, "w") as f:
+                json.dump(default_registry, f, indent=2)
+            return default_registry
+        
+        with open(self.auth_file, "r") as f:
+            return json.load(f)
+
+    def save_registry(self):
+        with open(self.auth_file, "w") as f:
+            json.dump(self.registry, f, indent=2)
+
+    def generate_key(self, owner, initial_credits=100):
+        """Génère un identifiant unique pour un nouveau client."""
+        new_key = f"xell-{secrets.token_hex(4)}"
+        self.registry[new_key] = {
+            "owner": owner,
+            "credits": initial_credits,
+            "active": True
+        }
+        self.save_registry()
+        return new_key
+
+    def validate_key(self, api_key):
+        """Vérifie si la clé est valide et active."""
+        return api_key in self.registry and self.registry[api_key]["active"]
+
+    def deduct_credits(self, api_key, word_count):
+        """Décompte chaque mot traduit du crédit de l'utilisateur."""
+        if not self.validate_key(api_key):
+            return False
+        
+        current_credits = self.registry[api_key]["credits"]
+        if current_credits < word_count:
+            return False # Solde insuffisant
+            
+        self.registry[api_key]["credits"] -= word_count
+        self.save_registry()
+        return True
+
+    def get_remaining_credits(self, api_key):
+        if self.validate_key(api_key):
+            return self.registry[api_key]["credits"]
+        return 0

guineapular-1.0.0/pular_core/context.py

@@ -0,0 +1,89 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
+class PularContextAnalyzer:
+    """
+    L'Analyseur de Contexte (Sub-Programme 3).
+    Gère les règles de successivité, les objets directes et les nuances sémantiques.
+    """
+    
+    def __init__(self, engine, knowledge):
+        self.engine = engine
+        self.knowledge = knowledge
+
+    def apply_object_suffix(self, verb_french, person_idx_subject, tense_key, object_person_key):
+        """
+        Gère l'objet : Coller les suffixes -lan (moi) ou -ma (toi) directement après la racine.
+        """
+        verb_data = self.knowledge.get_verb_data(verb_french)
+        if not verb_data:
+            return None
+        
+        root = verb_data["root"]
+        obj_suffix = self.knowledge.data.get("grammar", {}).get("pronoms_objet", {}).get(object_person_key)
+        
+        if not obj_suffix:
+            return self.engine.conjugate(verb_french, tense_key, person_idx_subject)
+        
+        # Le pronom sujet reste celui de la règle générale
+        # Le suffixe de conjugaison vient APRES l'objet?
+        # En Pular, c'est Racine + Objet + Suffixe (souvent)
+        # Mais le user dit: "Coller les suffixes -lan (moi) ou -ma (toi) directement après la racine."
+        
+        pronom_sujet = self.engine.conjugate(verb_french, tense_key, person_idx_subject).split(" ")[0]
+        conj_suffix = self.knowledge.get_suffix(tense_key if tense_key != "present" else "present")
+        
+        # Simplification selon instruction user: Racine + Objet
+        # Ex: Mi gnam-lan (Je me mange?) -> Plus réaliste: A gnam-lan (Tu me manges)
+        # On va suivre l'instruction: "Coller ... directement après la racine"
+        return f"{pronom_sujet} {root}{obj_suffix}{conj_suffix if conj_suffix else ''}"
+
+    def resolve_double_verb(self, subject_idx, v1_french, v2_french, tense_key):
+        """Règle du Double Verbe : Verbe 1 conjugué, Verbe 2 en -gol."""
+        return self.engine.apply_successivity([v1_french, v2_french], subject_idx, tense_key)
+
+    def handle_identity(self, term, is_negative=False):
+        """Gère le module Identité et la logique de classe adjectivale."""
+        data = self.knowledge.find_in_lexicon("identity", term)
+        if not data: return None
+        
+        if isinstance(data, dict) and "root" in data:
+            # Logique d'adjectif (ex: Labba-)
+            root = data["root"]
+            if is_negative:
+                return f"{root}{data.get('negation', 'ta')}"
+            return f"{root}" # En Pular, la racine peut être l'état
+            
+        return data
+
+    def evaluate_ethics(self, is_good=True):
+        """Module Éthique (Sarah's Ethics)."""
+        section = self.knowledge.find_in_lexicon("ethics", "bien_bon" if is_good else "mal_mauvais")
+        return section
+
+    def get_conversation_pair(self, word_french):
+        """Action-Réaction logic for conversation module."""
+        data = self.knowledge.find_in_lexicon("conversation", word_french)
+        if not data: return None
+        
+        if isinstance(data, dict):
+            return data.get("pular")
+        return data
+
+    def handle_nuance(self, word_french):
+        """
+        Gestion des Nuances (Paires Critiques).
+        Ex: Weela (Faim), Welii (Doux), Welaa (Pas doux).
+        """
+        # On cherche d'abord dans les verbes, puis dans le lexique
+        # Cette partie sera enrichie selon les retours utilisateur
+        if word_french.lower() == "faim":
+            return "weela"
+        if word_french.lower() == "doux":
+            return "welii"
+        if word_french.lower() == "pas doux":
+            return "welaa"
+            
+        return self.knowledge.find_in_lexicon("quantities", word_french) \
+               or self.knowledge.find_in_lexicon("meteo", word_french)

guineapular-1.0.0/pular_core/engine.py

@@ -0,0 +1,100 @@
+import re
+import logging
+
+logger = logging.getLogger(__name__)
+
+class PularEngine:
+    """
+    Le moteur déterministe de transformation linguistique.
+    Applique la matrice de conjugaison, les pronoms, la successivité verbale
+    et les règles syntaxiques (mots fantômes).
+    """
+    
+class PularEngine:
+    """
+    Le moteur déterministe de transformation linguistique.
+    Applique la matrice de conjugaison, les pronoms, la successivité verbale
+    et les règles syntaxiques.
+    """
+    
+    def __init__(self, knowledge):
+        self.knowledge = knowledge
+
+    def get_infinitive(self, verb_french):
+        """Calcule l'infinitif selon l'Algorithme de l'Infinitif."""
+        verb_data = self.knowledge.get_verb_data(verb_french)
+        if not verb_data:
+            return None
+        
+        root = verb_data["root"]
+        v_type = verb_data["type"] # type_1, type_2, type_3
+        
+        if v_type == "type_1":
+            return f"{root}ugol"
+        elif v_type == "type_2":
+            return f"{root}gol"
+        elif v_type == "type_3":
+            return f"{root}agol"
+        return f"{root}gol" # Default
+
+    def conjugate(self, verb_french, tense_key, person_index, is_negative=False):
+        """
+        Applique les règles de conjugaison sur un verbe.
+        person_index: 0(1S) à 5(3P)
+        """
+        verb_data = self.knowledge.get_verb_data(verb_french)
+        if not verb_data:
+            logger.warning(f"Données inconnues pour le verbe : {verb_french}")
+            return verb_french
+        
+        root = verb_data["root"]
+        v_type = verb_data["type"]
+        is_reflexive = (v_type == "type_3")
+
+        # Configuration par défaut
+        set_key = "set_A"
+        suffix_key = tense_key
+
+        if is_negative:
+            set_key = "set_A"
+            suffix_key = "negation"
+        elif tense_key == "present":
+            set_key = "set_B"
+            suffix_key = "present_reflexive" if is_reflexive else "present"
+        elif tense_key == "past":
+            set_key = "set_A"
+            suffix_key = "past_reflexive" if is_reflexive else "past"
+        elif tense_key == "futur":
+            set_key = "set_A"
+            suffix_key = "futur"
+
+        pronom = self.knowledge.get_subject_pronom(set_key, person_index)
+        suffix = self.knowledge.get_suffix(suffix_key)
+
+        if not pronom or suffix is None:
+            return f"{root}"
+
+        return f"{pronom} {root}{suffix}"
+
+    def apply_successivity(self, verbs_french, subject_idx, tense_key):
+        """
+        Applique la règle de successivité verbale : 
+        V1 conjugué, V2+ à l'infinitif.
+        """
+        if not verbs_french:
+            return ""
+        
+        results = []
+        # Premier verbe conjugué
+        results.append(self.conjugate(verbs_french[0], tense_key, subject_idx))
+        
+        # Suivants à l'infinitif
+        for v in verbs_french[1:]:
+            inf = self.get_infinitive(v)
+            results.append(inf if inf else v)
+            
+        return " ".join(results)
+
+    def translate_simple_sentence(self, subject_idx, verb_french, tense_key, is_negative=False):
+        """Traduit une phrase simple Sujet + Verbe."""
+        return self.conjugate(verb_french, tense_key, subject_idx, is_negative)

guineapular-1.0.0/pular_core/knowledge.py

@@ -0,0 +1,83 @@
+import json
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+class PularKnowledge:
+    """
+    Gère la Source de Vérité (Master Dictionary).
+    Responsable du chargement, de la sauvegarde, de la recherche de racines,
+    suffixes, pronoms et de la gestion de la polysémie.
+    """
+    
+    def __init__(self, data_path=None):
+        if data_path is None:
+            # Recherche relative au fichier (pour support pip install)
+            base_dir = os.path.dirname(__file__)
+            data_path = os.path.join(base_dir, "data", "dictionary.json")
+        self.data_path = data_path
+        self.data = self._load_data()
+        
+    def _load_data(self):
+        """Charge le dictionnaire JSON."""
+        if not os.path.exists(self.data_path):
+            logger.error(f"Fichier de données introuvable : {self.data_path}")
+            return {}
+        try:
+            with open(self.data_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception as e:
+            logger.error(f"Erreur lors du chargement du JSON : {e}")
+            return {}
+
+    def save_data(self):
+        """Sauvegarde les modifications dans le fichier JSON."""
+        try:
+            with open(self.data_path, "w", encoding="utf-8") as f:
+                json.dump(self.data, f, indent=2, ensure_ascii=False)
+            return True
+        except Exception as e:
+            logger.error(f"Erreur lors de la sauvegarde du JSON : {e}")
+            return False
+
+    def get_verb_data(self, french_verb):
+        """Récupère les données complètes d'un verbe (racine, type, catégorie)."""
+        return self.data.get("verbs", {}).get(french_verb.lower())
+
+    def get_verb_root(self, french_verb):
+        """Récupère la racine Pular d'un verbe français."""
+        data = self.get_verb_data(french_verb)
+        return data.get("root") if data else None
+
+    def get_suffix(self, suffix_key):
+        """Récupère un suffixe de grammaire."""
+        return self.data.get("grammar", {}).get("suffixes", {}).get(suffix_key)
+
+    def get_pronom_set(self, set_key):
+        """Récupère une liste de pronoms (set_A ou set_B)."""
+        return self.data.get("grammar", {}).get("pronoms_sujet", {}).get(set_key)
+
+    def get_subject_pronom(self, set_key, person_index):
+        """
+        Récupère le pronom spécifique pour une personne.
+        person_index: 0=1S, 1=2S, 2=3S, 3=1P, 4=2P, 5=3P
+        """
+        pronoms = self.get_pronom_set(set_key)
+        if pronoms and 0 <= person_index < len(pronoms):
+            return pronoms[person_index]
+        return None
+
+    def find_in_lexicon(self, section, key):
+        """Recherche dans le lexique (quantities, numbers, meteo, etc.)."""
+        return self.data.get("lexicon", {}).get(section, {}).get(key.lower())
+
+    def update_word(self, section, french_word, pular_data):
+        """Ajoute ou met à jour un mot dans le lexique."""
+        if "lexicon" not in self.data:
+            self.data["lexicon"] = {}
+        if section not in self.data["lexicon"]:
+            self.data["lexicon"][section] = {}
+        
+        self.data["lexicon"][section][french_word.lower()] = pular_data
+        return self.save_data()

guineapular-1.0.0/pular_core/validator.py

@@ -0,0 +1,41 @@
+import re
+
+class PularValidator:
+    """
+    Assure la conformité typographique et le système de confiance.
+    """
+    
+    def __init__(self):
+        # Caractères Pular spécifiques
+        self.pular_chars = {
+            'b_impl': 'ɓ',
+            'd_impl': 'ɗ',
+            'y_impl': 'ƴ',
+            'n_nasal': 'ŋ',
+            'ny': 'ñ'
+        }
+
+    def normalize_typography(self, text):
+        """
+        Remplace les tentatives de caractères Pular approximatifs par les officiels.
+        Note: Cette logique peut être étendue selon les besoins utilisateurs.
+        """
+        if not text:
+            return text
+        
+        # Exemple de normalisation (à enrichir via apprentissage)
+        # Ici on pourrait intégrer l'enforcement Mi do -> Mi ɗo
+        normalized = text.replace(" do", " ɗo")
+        # On pourrait aussi mapper des combinaisons de touches spécifiques
+        return normalized
+
+    def validate_pular_entry(self, word):
+        """Vérifie si un mot contient les caractères attendus (aide à l'apprentissage)."""
+        # Logic pour suggérer ɗ au lieu de d si le dictionnaire l'indique
+        pass
+
+    def check_confidence(self, current_score, conflict=False):
+        """Gère l'évolution du score de confiance."""
+        if conflict:
+            return max(1, current_score - 1)
+        return min(5, current_score + 1)

guineapular-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

guineapular-1.0.0/setup.py

@@ -0,0 +1,20 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="guineapular",
+    version="1.0.0",
+    packages=find_packages(),
+    include_package_data=True,
+    install_requires=[
+        "setuptools",
+        "fastapi",
+        "uvicorn"
+    ],
+    author="Keit Xellker & User",
+    description="Le cerveau déterministe de l'IA Pular-Learning",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent",
+    ],
+    python_requires='>=3.6',
+)