think definitions draft

lib/grapher.py

@@ -18,7 +18,7 @@ class APIRequester:
         else:
             return None
 
-class JSONParser:
+class Grapher:
     def __init__(self, memoria_nlp, threshold=70):
         self.threshold = threshold
         self.graph = nx.Graph()
@@ -89,27 +89,30 @@ class JSONParser:
                 for vecino in otro_grafo.neighbors(nodo):
                     self.graph.add_edge(nodo, vecino)
 
-# Ejemplo de uso
-memoria_nlp = MemoriaRobotNLP(max_size=100)
-json_parser = JSONParser(memoria_nlp)
 
-api_requester = APIRequester()
-url = "https://jsonplaceholder.typicode.com/posts"
-data = api_requester.make_request(url)
+if __name__ == "__main__":
 
-if data:
-    json_parser.parse_json(data)
-    json_parser.draw_graph()
-    
-    otro_parser = JSONParser(MemoriaRobotNLP(max_size=100))
-    otro_parser.parse_json({"id": 101, "title": "New Title", "userId": 11})
-    
-    print("Uniendo los grafos...")
-    json_parser.unir_grafos(otro_parser.graph, umbral=80)
-    print("Grafo unido:")
-    json_parser.draw_graph()
-    
-    json_parser.guardar_en_memoria()
-else:
-    print("Error al realizar la solicitud a la API.")
+    # Ejemplo de uso
+    memoria_nlp = MemoriaRobotNLP(max_size=100)
+    json_parser = JSONParser(memoria_nlp)
+
+    api_requester = APIRequester()
+    url = "https://jsonplaceholder.typicode.com/posts"
+    data = api_requester.make_request(url)
+
+    if data:
+        json_parser.parse_json(data)
+        json_parser.draw_graph()
+        
+        otro_parser = JSONParser(MemoriaRobotNLP(max_size=100))
+        otro_parser.parse_json({"id": 101, "title": "New Title", "userId": 11})
+        
+        print("Uniendo los grafos...")
+        json_parser.unir_grafos(otro_parser.graph, umbral=80)
+        print("Grafo unido:")
+        json_parser.draw_graph()
+        
+        json_parser.guardar_en_memoria()
+    else:
+        print("Error al realizar la solicitud a la API.")
 

lib/me.py

@@ -1,10 +1,19 @@
+from lib.files import *
 from lib.memory import *
 from lib.grapher import *
 from lib.pipes import *
 from lib.entropy import *
+from lib.sonsofstars import *
+import internetarchive
+
+longMem = TextFinder("resources")
+coreAi = AIAssistant()
+memory = MemoriaRobotNLP(max_size=200000)
+grapher = Grapher(memoria_nlp)
+sensor_request = APIRequester()
 
 class I:
-    def __init__(self, frases_yo, preferencias, propiedades_persona):
+    def __init__(self, prompt, frases_yo, preferencias, propiedades_persona):
         self.frases_yo = frases_yo
         self.preferencias = preferencias
         self.propiedades_persona = propiedades_persona
@@ -21,15 +30,95 @@ class I:
 
         pass
 
+    ## create questions from internet archive 
+    def crear_preguntas(self,txt):
+        search = internetarchive.search_items(sys.argv[1])
+        res = []
+        for result in search:
+            print(result['identifier'])
+            idc=result["identifier"]
+            
+
+            headers = {"accept": "application/json"}
+
+        ## get book pages
+            req2 = requests.get("https://archive.org/stream/"+idc+"/"+idc+"_djvu.txt",headers=headers)
+        #print(req2.text)
+            try:
+                txt = req2.text.split("<pre>")[1].split("</pre>")[0].split(" <!--")[0]
+
+                for x in txt.split("\n"):
+                    if "?" in x:
+                        res.append(x)
+
+            except:
+                pass
+
+        return res
+
+
+    # generate thinks and questions over prompt data, compare with ourself datasets, return matches with sentiment analysys
+    def think_gen(self,txt):
+        
+        think_about = longMem.find_matches(txt)
+        for T in thinkabout:
+            ## get subject by entropy or pos tagger
+            subjects = coreAi.entity_pos_tagger(txt)
+            ## get NC from , filtering from gramatical tags
+            subjects_low = coreAi.grammatical_pos_tagger(txt)
+            ## generate questoins
+            questions=[]
+            ## create cuestions from internet archive books
+            for sub in subjects:
+                questions.append(this.crear_preguntas(txt))
+            
+            ## fast checks from gematria similarity
+            ##questions_togem = 
+            ## gematria_search =
+
+            questions_subj=[]
+            for q in questoins:
+                questions_subj.append(coreAi.entity_pos_tagger(q))
+            
+            memoryShortTags = memory.buscar_conceptos_patron(subjects)
+
+            ## get tags of subject
+            subj_tags = coreAi.entity_pos_tagger(T)
+            
+            for sub in subjects: 
+                memory.agregar_concepto(sub,",".(questions_subj)+",".join(memoryShortTags))
+                memory.agregar_concepto(sub,T+",".join(memoryShortTags))
+
+
+        ## check if something is need to add to ourself datasets
+        ## make sentiment analys
+        ## check if dopamine prompt is true or false over the information
+        ## set weight to information depending of generated dopamine
+        ## add dopamine wights to the dopamine concept dataset
+
+
+
+    def crear_path_grafo(self,text):
+        pos_tags = assistant.grammatical_pos_tagger(text)
+        ner_results = coreAi.entity_pos_tagger(text)
+
+
     def crear_circuito_logico(self):
         # Función para crear un circuito lógico con un algoritmo específico
         pass
 
-    def tomar_decision_sentimiento(self, pipa_sentimiento):
+    def tomar_decision_sentimiento(self, sentimiento):
+        
+        sentiments = coreAi.sentiment_tags(sentimiento)
         # Función para tomar una decisión booleana con un análisis de sentimiento
-        pass
+        similarity = coreAi.similarity_tag(self, sentenceA,sentenceB)
+        ## Check by similarity over memory tag paths
+
+
+        return sentiments
 
     def hacer_predicciones_texto(self, texto):
+
         # Función para hacer predicciones de texto futuro por similitud
         pass
 

lib/memory.py

@@ -24,6 +24,17 @@ class MemoriaRobotNLP:
         if concepto in self.memoria:
             self.memoria[concepto] = [(s, p) for s, p in self.memoria[concepto] if s != string]
 
+    def buscar_conceptos_patron(self, patron):
+            resultados = {}
+
+            for concepto, strings in self.memoria.items():
+                for string, _ in strings:
+                    if re.search(patron, string):
+                        if concepto not in resultados:
+                            resultados[concepto] = []
+                        resultados[concepto].append(string)
+
+        return resultados
     def obtener_conceptos_acotados(self, espacio_disponible):
         memoria_ordenada = sorted(self.memoria.items(), key=lambda x: sum(prioridad for _, prioridad in x[1]), reverse=True)
         espacio_utilizado = 0