Translate identifiers, comments and docstrings to EnglishHEADmain

The CLI output and help stay in Spanish, as documented in the README.

1 files changed, 73 insertions, 73 deletions

diff --git a/tests/test_memory.py b/tests/test_memory.py
index 6491c9b..460d4ec 100644
--- a/tests/test_memory.py
+++ b/tests/test_memory.py
@@ -10,7 +10,7 @@ from .fixtures import (
 
 
 class MemoryCase(unittest.TestCase):
-    """Cada test corre contra un ~/.claude/projects de mentira."""
+    """Each test runs against a fake ~/.claude/projects."""
 
     def setUp(self):
         self._tmp = tempfile.TemporaryDirectory()
@@ -18,14 +18,14 @@ class MemoryCase(unittest.TestCase):
         self.root = os.path.join(self._tmp.name, "projects")
         os.makedirs(self.root)
 
-    def cargar(self):
-        """Sesiones + memorias del árbol, como las ve la CLI."""
+    def load_items(self):
+        """Sessions + memories of the tree, as the CLI sees them."""
         ss = sessions.load_sessions(root=self.root, use_cache=False)
         return ss, memory.load_memories(ss, root=self.root)
 
 
-class TestParseo(MemoryCase):
-    def test_lee_frontmatter_y_cuerpo(self):
+class TestParsing(MemoryCase):
+    def test_reads_frontmatter_and_body(self):
         path = write_memory(self.root, "-home-u-proj", "una",
                             body="el cuerpo", desc="qué es", kind="feedback",
                             origin="abc123")
@@ -36,14 +36,14 @@ class TestParseo(MemoryCase):
         self.assertEqual(m["src"], "abc123")
         self.assertEqual(m["body"], "el cuerpo")
 
-    def test_descripcion_entrecomillada_pierde_los_escapes(self):
-        # Claude escribe la descripción como string YAML cuando trae comillas.
+    def test_quoted_description_loses_the_escapes(self):
+        # Claude writes the description as a YAML string when it contains quotes.
         path = write_memory(self.root, "-home-u-proj", "q",
                             desc=r'"la máquina \"legion\" y algo"')
         self.assertEqual(memory.read_memory(path, "-home-u-proj")["desc"],
                          'la máquina "legion" y algo')
 
-    def test_sin_frontmatter_cae_al_nombre_del_archivo(self):
+    def test_no_frontmatter_falls_back_to_the_file_name(self):
         path = write_memory(self.root, "-home-u-proj", "pelada",
                             body="solo texto", frontmatter=False)
         m = memory.read_memory(path, "-home-u-proj")
@@ -51,78 +51,78 @@ class TestParseo(MemoryCase):
         self.assertEqual(m["ty"], "—")
         self.assertEqual(m["body"], "solo texto")
 
-    def test_junta_los_enlaces_sin_repetir(self):
+    def test_collects_links_without_repeats(self):
         path = write_memory(self.root, "-home-u-proj", "l",
                             body="[[uno]] y [[dos]] y otra vez [[uno]]")
         self.assertEqual(memory.read_memory(path, "-home-u-proj")["ln"],
                          ["dos", "uno"])
 
 
-class TestCarga(MemoryCase):
-    def test_resuelve_la_ruta_del_proyecto_desde_las_sesiones(self):
+class TestLoading(MemoryCase):
+    def test_resolves_the_project_path_from_the_sessions(self):
         simple_tree(self.root)
         memory_tree(self.root)
-        _, mems = self.cargar()
+        _, mems = self.load_items()
         deploy = next(m for m in mems if m["name"] == "deploy-docker")
         self.assertEqual(deploy["p"], "/home/u/proj")
 
-    def test_sin_sesiones_deja_el_nombre_codificado(self):
-        # No se puede invertir: "/" y "." se codifican los dos como "-".
+    def test_no_sessions_keeps_the_encoded_name(self):
+        # It cannot be reversed: "/" and "." are both encoded as "-".
         memory_tree(self.root)
-        _, mems = self.cargar()
+        _, mems = self.load_items()
         self.assertEqual(
             next(m for m in mems if m["name"] == "deploy-docker")["p"],
             "-home-u-proj")
 
-    def test_ignora_los_directorios_memory_vacios(self):
+    def test_ignores_empty_memory_directories(self):
         memory_tree(self.root)
-        _, mems = self.cargar()
+        _, mems = self.load_items()
         self.assertNotIn("-home-u-vacio", {m["project_dir"] for m in mems})
 
-    def test_marca_lo_que_esta_en_el_indice(self):
+    def test_marks_what_is_in_the_index(self):
         memory_tree(self.root)
-        _, mems = self.cargar()
-        por_nombre = {m["name"]: m for m in mems}
-        self.assertTrue(por_nombre["deploy-docker"]["ix"])
-        self.assertFalse(por_nombre["suelta"]["ix"])
-        self.assertTrue(por_nombre["suelta"]["hix"])
-        self.assertFalse(por_nombre["sin-indice"]["hix"])
-
-    def test_ordena_por_fecha_descendente(self):
+        _, mems = self.load_items()
+        by_name = {m["name"]: m for m in mems}
+        self.assertTrue(by_name["deploy-docker"]["ix"])
+        self.assertFalse(by_name["suelta"]["ix"])
+        self.assertTrue(by_name["suelta"]["hix"])
+        self.assertFalse(by_name["sin-indice"]["hix"])
+
+    def test_sorts_by_date_descending(self):
         memory_tree(self.root)
-        _, mems = self.cargar()
-        fechas = [m["l"] for m in mems]
-        self.assertEqual(fechas, sorted(fechas, reverse=True))
+        _, mems = self.load_items()
+        dates = [m["l"] for m in mems]
+        self.assertEqual(dates, sorted(dates, reverse=True))
 
-    def test_public_records_saca_las_claves_internas(self):
+    def test_public_records_drops_internal_keys(self):
         memory_tree(self.root)
-        _, mems = self.cargar()
+        _, mems = self.load_items()
         for m in memory.public_records(mems):
             self.assertNotIn("project_dir", m)
-        # El original no se toca.
+        # The original is left untouched.
         self.assertIn("project_dir", mems[0])
 
 
-class TestFiltros(MemoryCase):
+class TestFilters(MemoryCase):
     def setUp(self):
         super().setUp()
         simple_tree(self.root)
         memory_tree(self.root)
-        _, self.mems = self.cargar()
+        _, self.mems = self.load_items()
 
-    def test_por_tipo(self):
+    def test_by_type(self):
         r = memory.apply_filters(self.mems, kind="reference")
         self.assertEqual([m["name"] for m in r], ["roles-db"])
 
-    def test_por_proyecto(self):
+    def test_by_project(self):
         r = memory.apply_filters(self.mems, project="/home/u/proj")
         self.assertNotIn("sin-indice", [m["name"] for m in r])
 
-    def test_la_query_entra_al_cuerpo(self):
+    def test_query_reaches_the_body(self):
         r = memory.apply_filters(self.mems, query="make up")
         self.assertEqual([m["name"] for m in r], ["deploy-docker"])
 
-    def test_la_query_tambien_mira_la_descripcion(self):
+    def test_query_also_checks_the_description(self):
         r = memory.apply_filters(self.mems, query="huérfana")
         self.assertEqual([m["name"] for m in r], ["suelta"])
 
@@ -131,98 +131,98 @@ class TestPick(MemoryCase):
     def setUp(self):
         super().setUp()
         memory_tree(self.root)
-        _, self.mems = self.cargar()
+        _, self.mems = self.load_items()
 
-    def test_por_indice(self):
+    def test_by_index(self):
         self.assertEqual(memory.pick(self.mems, "1"), self.mems[0])
 
-    def test_indice_fuera_de_rango(self):
+    def test_index_out_of_range(self):
         with self.assertRaises(sessions.SessionError):
             memory.pick(self.mems, "99")
 
-    def test_por_prefijo(self):
+    def test_by_prefix(self):
         self.assertEqual(memory.pick(self.mems, "deploy")["name"], "deploy-docker")
 
-    def test_cae_a_subcadena(self):
+    def test_falls_back_to_substring(self):
         self.assertEqual(memory.pick(self.mems, "docker")["name"], "deploy-docker")
 
     def test_sin_coincidencias(self):
         with self.assertRaises(sessions.SessionError):
             memory.pick(self.mems, "nada-que-ver")
 
-    def test_ambiguo(self):
+    def test_ambiguous(self):
         write_memory(self.root, "-home-u-proj", "deploy-otro")
-        _, mems = self.cargar()
+        _, mems = self.load_items()
         with self.assertRaises(sessions.SessionError) as ctx:
             memory.pick(mems, "deploy")
         self.assertIn("ambiguo", str(ctx.exception))
 
 
-class TestAuditoria(MemoryCase):
+class TestAudit(MemoryCase):
     def setUp(self):
         super().setUp()
         simple_tree(self.root)
         memory_tree(self.root)
-        self.ss, self.mems = self.cargar()
+        self.ss, self.mems = self.load_items()
         self.report = memory.audit(self.mems, self.ss, root=self.root)
 
-    def test_proyecto_sin_indice(self):
+    def test_project_without_index(self):
         self.assertEqual([m["name"] for m in self.report["sin_indice"]],
                          ["sin-indice"])
 
-    def test_memoria_fuera_del_indice(self):
+    def test_memory_outside_the_index(self):
         self.assertEqual([m["name"] for m in self.report["sin_listar"]],
                          ["suelta"])
 
-    def test_entrada_del_indice_sin_archivo(self):
+    def test_index_entry_without_file(self):
         self.assertEqual([n for _, n in self.report["indice_fantasma"]],
                          ["borrada-hace-rato"])
 
-    def test_enlace_roto(self):
-        rotos = [link for _, link in self.report["enlaces_rotos"]]
-        self.assertEqual(rotos, ["no-existe"])  # [[roles-db]] sí resuelve
+    def test_broken_link(self):
+        broken = [link for _, link in self.report["enlaces_rotos"]]
+        self.assertEqual(broken, ["no-existe"])  # [[roles-db]] does resolve
 
-    def test_sesion_de_origen_perdida(self):
-        # deploy-docker apunta a una sesión que existe; sin-indice no.
+    def test_lost_origin_session(self):
+        # deploy-docker points to a session that exists; sin-indice does not.
         self.assertEqual([m["name"] for m in self.report["origen_perdido"]],
                          ["sin-indice"])
 
-    def test_arbol_consistente_no_reporta_nada(self):
-        limpio = os.path.join(self._tmp.name, "limpio")
-        os.makedirs(limpio)
-        write_memory(limpio, "-p", "sola", body="sin enlaces")
-        write_index(limpio, "-p", ["sola"])
-        mems = memory.load_memories([], root=limpio)
-        self.assertEqual(memory.audit_total(memory.audit(mems, [], root=limpio)), 0)
+    def test_consistent_tree_reports_nothing(self):
+        is_clean = os.path.join(self._tmp.name, "limpio")
+        os.makedirs(is_clean)
+        write_memory(is_clean, "-p", "sola", body="sin enlaces")
+        write_index(is_clean, "-p", ["sola"])
+        mems = memory.load_memories([], root=is_clean)
+        self.assertEqual(memory.audit_total(memory.audit(mems, [], root=is_clean)), 0)
 
 
-class TestBorrado(MemoryCase):
+class TestDeletion(MemoryCase):
     def setUp(self):
         super().setUp()
         memory_tree(self.root)
-        _, self.mems = self.cargar()
+        _, self.mems = self.load_items()
 
-    def por_nombre(self, name):
+    def by_name(self, name):
         return next(m for m in self.mems if m["name"] == name)
 
-    def test_borra_el_archivo_y_lo_desindexa(self):
-        m = self.por_nombre("deploy-docker")
+    def test_deletes_the_file_and_unindexes_it(self):
+        m = self.by_name("deploy-docker")
         self.assertTrue(memory.delete(m, root=self.root))
         self.assertFalse(os.path.exists(memory.memory_path(m, self.root)))
         self.assertNotIn("deploy-docker",
                          memory.read_index("-home-u-proj", self.root))
 
-    def test_desindexar_no_toca_las_otras_lineas(self):
-        memory.unindex(self.por_nombre("deploy-docker"), root=self.root)
+    def test_unindexing_leaves_other_lines_alone(self):
+        memory.unindex(self.by_name("deploy-docker"), root=self.root)
         self.assertIn("roles-db", memory.read_index("-home-u-proj", self.root))
 
-    def test_borrar_una_que_no_estaba_indexada(self):
-        m = self.por_nombre("suelta")
+    def test_delete_one_that_was_not_indexed(self):
+        m = self.by_name("suelta")
         self.assertFalse(memory.delete(m, root=self.root))
         self.assertFalse(os.path.exists(memory.memory_path(m, self.root)))
 
-    def test_borrar_sin_memory_md(self):
-        m = self.por_nombre("sin-indice")
+    def test_delete_without_memory_md(self):
+        m = self.by_name("sin-indice")
         self.assertFalse(memory.delete(m, root=self.root))
         self.assertFalse(os.path.exists(memory.memory_path(m, self.root)))