memory draf lib, grapher draft lib

lib/grepher.py

@@ -0,0 +1,115 @@
+import requests
+import json
+import networkx as nx
+import matplotlib.pyplot as plt
+from fuzzywuzzy import fuzz
+from fuzzywuzzy import process
+from lib.memory import *
+
+
+class APIRequester:
+    def __init__(self):
+        pass
+
+    def make_request(self, url):
+        response = requests.get(url)
+        if response.status_code == 200:
+            return response.json()
+        else:
+            return None
+
+class JSONParser:
+    def __init__(self, memoria_nlp, threshold=70):
+        self.threshold = threshold
+        self.graph = nx.Graph()
+        self.memoria_nlp = memoria_nlp
+
+    def parse_json(self, data, parent=None):
+        if isinstance(data, dict):
+            for key, value in data.items():
+                if parent:
+                    self.graph.add_node(parent)
+                    self.graph.add_node(key)
+                    self.graph.add_edge(parent, key)
+
+                    for node in self.graph.nodes():
+                        if node != parent and fuzz.ratio(node, key) >= self.threshold:
+                            self.graph = nx.contracted_nodes(self.graph, node, key, self_loops=False)
+
+                self.memoria_nlp.agregar_concepto("keys", [(key, 1.0)])
+
+                if isinstance(value, (dict, list)):
+                    self.parse_json(value, key)
+                else:
+                    self.memoria_nlp.agregar_concepto("values", [(str(value), 1.0)])
+                    if parent:
+                        self.graph.add_node(value)
+                        self.graph.add_edge(key, value)
+
+                        for node in self.graph.nodes():
+                            if node != value and fuzz.ratio(node, value) >= self.threshold:
+                                self.graph = nx.contracted_nodes(self.graph, node, value, self_loops=False)
+        elif isinstance(data, list):
+            for item in data:
+                self.parse_json(item, parent)
+
+    def draw_graph(self):
+        pos = nx.spring_layout(self.graph, seed=42)
+        nx.draw(self.graph, pos, with_labels=True, node_size=700, node_color='skyblue', font_size=10, font_weight='bold')
+        plt.title("JSON Graph")
+        plt.show()
+
+    def guardar_en_memoria(self):
+        keys = self.memoria_nlp.obtener_conceptos_acotados(100)
+        with open("memoria.json", "w") as file:
+            json.dump(keys, file)
+            
+    def buscar_nodo(self, nodo):
+        return process.extractOne(nodo, self.graph.nodes())[0]
+    
+    def eliminar_nodo(self, nodo):
+        self.graph.remove_node(nodo)
+    
+    def agregar_nodo(self, nodo):
+        self.graph.add_node(nodo)
+    
+    def distancia_entre_nodos(self, nodo1, nodo2):
+        return nx.shortest_path_length(self.graph, source=nodo1, target=nodo2)
+    
+    def ruta_entre_nodos(self, nodo1, nodo2):
+        return nx.shortest_path(self.graph, source=nodo1, target=nodo2)
+    
+    def unir_grafos(self, otro_grafo, umbral):
+        for nodo in otro_grafo.nodes():
+            nodo_similar = process.extractOne(nodo, self.graph.nodes())[0]
+            if fuzz.ratio(nodo, nodo_similar) >= umbral:
+                self.graph = nx.contracted_nodes(self.graph, nodo_similar, nodo, self_loops=False)
+            else:
+                self.graph.add_node(nodo)
+                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 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/memory.py

@@ -0,0 +1,62 @@
+class MemoriaRobotNLP:
+    def __init__(self, max_size):
+        self.max_size = max_size
+        self.memoria = {}
+
+    def agregar_concepto(self, concepto, strings):
+        if concepto not in self.memoria:
+            self.memoria[concepto] = []
+
+        for string, prioridad in strings:
+            self.memoria[concepto].append((string, prioridad))
+
+    def eliminar_concepto(self, concepto):
+        if concepto in self.memoria:
+            del self.memoria[concepto]
+
+    def agregar_string(self, concepto, string, prioridad):
+        if concepto not in self.memoria:
+            self.memoria[concepto] = []
+
+        self.memoria[concepto].append((string, prioridad))
+
+    def eliminar_string(self, concepto, string):
+        if concepto in self.memoria:
+            self.memoria[concepto] = [(s, p) for s, p in self.memoria[concepto] if s != string]
+
+    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
+        conceptos_acotados = []
+
+        for concepto, strings in memoria_ordenada:
+            espacio_concepto = sum(prioridad for _, prioridad in strings)
+            if espacio_utilizado + espacio_concepto <= espacio_disponible:
+                conceptos_acotados.append((concepto, strings))
+                espacio_utilizado += espacio_concepto
+            else:
+                break
+
+        return conceptos_acotados
+
+
+# Ejemplo de uso
+memoria_robot = MemoriaRobotNLP(max_size=100)
+
+memoria_robot.agregar_concepto("animales", [("perro", 0.8), ("gato", 0.7), ("pájaro", 0.5)])
+memoria_robot.agregar_concepto("colores", [("rojo", 0.9), ("verde", 0.6), ("azul", 0.7)])
+
+print("Memoria completa:")
+print(memoria_robot.memoria)
+
+memoria_robot.agregar_string("animales", "pez", 0.6)
+memoria_robot.eliminar_string("colores", "verde")
+memoria_robot.eliminar_concepto("colores")
+
+print("\nMemoria después de modificaciones:")
+print(memoria_robot.memoria)
+
+conceptos_acotados = memoria_robot.obtener_conceptos_acotados(50)
+print("\nConceptos acotados a un tamaño máximo de memoria:")
+print(conceptos_acotados)
+