binary-equalab 3.0.0b1__py3-none-any.whl → 3.0.0b3__py3-none-any.whl

binary_equalab/cli.py

@@ -21,7 +21,7 @@ console = Console()
 
 BANNER = """
 [bold orange1]╔══════════════════════════════════════════════════════════╗
-║    [white]Binary EquaLab CLI[/white]   [dim]Aurora v2.0[/dim]                     ║
+║    [white]Binary EquaLab CLI[/white]   [dim]Aurora v3.0 (Beta)[/dim]              ║
 ║    [dim italic]"Las matemáticas también sienten,[/dim italic]                  ║
 ║    [dim italic] pero estas no se equivocan."[/dim italic]                  ║
 ╚══════════════════════════════════════════════════════════╝[/bold orange1]
@@ -80,8 +80,19 @@ HELP_TEXT = """
 | `tir(flujo0, flujo1, ...)` | `tir(-1000, 300, 400, 500)` |
 | `depreciar(costo, residual, años)` | `depreciar(10000, 1000, 5)` |
 | `interes_simple(capital, tasa, tiempo)` | `interes_simple(1000, 0.05, 3)` |
+| `interes_simple(capital, tasa, tiempo)` | `interes_simple(1000, 0.05, 3)` |
 | `interes_compuesto(capital, tasa, n, tiempo)` | `interes_compuesto(1000, 0.05, 12, 3)` |
 
+### Sistemas Numéricos (NUEVO)
+| Función | Ejemplo |
+|---------|---------|
+| `bin(n)` | `bin(10)` → `0b1010` |
+| `oct(n)` | `oct(10)` → `0o12` |
+| `hex(n)` | `hex(255)` → `0xff` |
+| `base(n, b)` | `base(10, 2)` → `1010` |
+
+### AI Assistant
+
 ### Aliases y Accesos Directos
 - **Shell**: Puedes ejecutar el programa como `binary-equalab`, `bneqls`, `beq` o `binary-math`.
 - **Trigonometría**: `seno`=`sin`, `coseno`=`cos`, `tangente`=`tan`.
@@ -99,7 +110,7 @@ def get_prompt_style():
 def print_banner():
     """Print the CLI banner using Rich panels."""
     title = Text("Binary EquaLab CLI", style="bold white")
-    version = Text("Aurora v2.0.2", style="dim")
+    version = Text("Aurora v3.0 (Beta)", style="dim")
     slogan = Text('"Las matemáticas también sienten,\npero estas no se equivocan."', style="dim italic")
 
     content = Text.assemble(title, "  ", version, "\n\n", slogan, justify="center")
@@ -219,9 +230,13 @@ def main():
     if len(sys.argv) > 1 and sys.argv[1] == 'setup-shell':
         from .shell_setup import run_setup
         run_setup()
+    elif len(sys.argv) > 1 and sys.argv[1] == 'tui':
+        from .tui import BinaryTUI
+        app = BinaryTUI()
+        app.run()
     elif len(sys.argv) > 1 and sys.argv[1] == 'ai':
-        # AI Commands Mode
-        from .kimi_service import kimi_service
+        # AI Commands Mode (Kimi K2)
+        from .services.kimi_service import kimi_service
         
         if len(sys.argv) < 3:
             console.print("[bold red]Uso:[/bold red] binary ai [solve|explain|exercises] \"consulta\"")
@@ -230,7 +245,6 @@ def main():
         subcmd = sys.argv[2]
         query = " ".join(sys.argv[3:])
         
-        # 'exercises' command doesn't necessarily need a query if defaults are used, but we'll use query as topic
         if subcmd != 'exercises' and not query:
              console.print("[bold red]Error:[/bold red] Falta la consulta.")
              sys.exit(1)
@@ -258,12 +272,15 @@ def main():
                 console.print(Panel(Markdown(response), title=f"Kimi AI: Explicación", border_style="blue"))
             
             elif subcmd == "exercises":
-                # Uso: binary ai exercises "Derivadas" [opcional: count]
-                # Por simplicidad en sys.argv, asumimos que todo el resto es el topic
-                exercises = kimi_service.generate_exercises(query if query else "Matemáticas generales")
+                count = 3 # default
+                # Simple parsing for count if present in args? For now keeping simple.
+                exercises = kimi_service.generate_exercises(query if query else "Matemáticas Generales", count)
                 
                 console.print(f"[bold u]Generando ejercicios para:[/bold u] {query}\n")
                 
+                if not exercises:
+                     console.print("No se pudieron generar ejercicios. Verifica tu API Key o intenta de nuevo.")
+
                 for i, ex in enumerate(exercises, 1):
                     console.print(Panel(
                         f"[bold]Pregunta:[/bold]\n{ex.get('problem')}\n\n"
@@ -271,10 +288,7 @@ def main():
                         title=f"Ejercicio {i}", border_style="magenta"
                     ))
                     if ex.get('steps'):
-                        with console.status(f"[dim]Ver pasos...[/dim]"):
-                            # Hack para ocultar pasos inicialmente si se quisiera, pero aquí los mostramos
-                            pass
-                        console.print(f"[dim]Pasos: {', '.join(ex.get('steps', []))}[/dim]\n")
+                         console.print(f"[dim]Pasos: {', '.join(ex.get('steps', []))}[/dim]\n")
             else:
                 console.print(f"[bold red]Comando desconocido:[/bold red] {subcmd}")
                 sys.exit(1)

binary_equalab/engine.py

@@ -74,6 +74,12 @@ class MathEngine:
             'recta': self._recta,
             'circulo': self._circulo,
             
+            # Numeral Systems
+            'bin': self._binario,
+            'oct': self._octal,
+            'hex': self._hexadecimal,
+            'base': self._base_n,
+            
             # Trigonometry aliases
             'seno': sin,
             'coseno': cos,
@@ -394,6 +400,41 @@ class MathEngine:
         engine = AudioEngine()
         return engine.generate(str(expr), float(duration), str(filename))
 
+    # ============ NUMERAL SYSTEMS ============
+
+    def _binario(self, number):
+        """Convert to binary: bin(10) → '0b1010'"""
+        try:
+            return bin(int(number))
+        except:
+            return bin(int(float(number)))
+
+    def _octal(self, number):
+        """Convert to octal: oct(10) → '0o12'"""
+        try:
+            return oct(int(number))
+        except:
+            return oct(int(float(number)))
+
+    def _hexadecimal(self, number):
+        """Convert to hex: hex(255) → '0xff'"""
+        try:
+            return hex(int(number))
+        except:
+            return hex(int(float(number)))
+
+    def _base_n(self, number, base):
+        """Convert to arbitrary base: base(10, 2) → '1010'"""
+        n = int(number)
+        b = int(base)
+        if n == 0:
+            return "0"
+        digits = []
+        while n:
+            digits.append(int(n % b))
+            n //= b
+        return "".join(str(d) for d in digits[::-1])
+
 # Convenience functions for direct import
 def derivar(expr, var=None, n=1):
     engine = MathEngine()
@@ -490,3 +531,19 @@ def circulo(centro, radio):
 def sonify(expr, duration=3.0, filename="output.wav"):
     engine = MathEngine()
     return engine._sonify(expr, duration, filename)
+
+def binario(number):
+    engine = MathEngine()
+    return engine._binario(number)
+
+def octal(number):
+    engine = MathEngine()
+    return engine._octal(number)
+
+def hexadecimal(number):
+    engine = MathEngine()
+    return engine._hexadecimal(number)
+
+def base(number, n):
+    engine = MathEngine()
+    return engine._base_n(number, n)

binary_equalab/services/kimi_service.py

@@ -0,0 +1,127 @@
+
+# binary-cli/binary_equalab/services/kimi_service.py
+
+import os
+import json
+import requests
+from typing import List, Dict, Optional, Any
+
+class KimiService:
+    """Service to interact with Kimi K2 (Moonshot AI) from CLI/Desktop"""
+    
+    def __init__(self):
+        # Allow checking multiple env locations or just env
+        self.api_key = os.getenv('KIMI_API_KEY', '')
+        self.base_url = 'https://api.moonshot.cn/v1'
+        self.model = 'moonshot-v1-128k'
+        
+        if not self.api_key:
+            # Try to read from .env if not loaded (though click/main usually loads it)
+            pass
+    
+    def chat(
+        self,
+        messages: List[Dict[str, str]],
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+        stream: bool = False
+    ) -> Any: # Returns str or iterator
+        """Send message to Kimi K2"""
+        
+        if not self.api_key:
+            raise ValueError("KIMI_API_KEY not configured. Set it in your environment.")
+        
+        headers = {
+            'Content-Type': 'application/json',
+            'Authorization': f'Bearer {self.api_key}'
+        }
+        
+        payload = {
+            'model': self.model,
+            'messages': messages,
+            'temperature': temperature,
+            'max_tokens': max_tokens,
+            'stream': stream
+        }
+        
+        response = requests.post(
+            f'{self.base_url}/chat/completions',
+            headers=headers,
+            json=payload,
+            stream=stream
+        )
+        
+        if not response.ok:
+            raise Exception(f"Kimi API Error: {response.status_code} - {response.text}")
+        
+        if stream:
+            return self._stream_response(response)
+        
+        data = response.json()
+        return data['choices'][0]['message']['content']
+
+    def _stream_response(self, response):
+        for line in response.iter_lines():
+            if line:
+                line = line.decode('utf-8')
+                if line.startswith('data: '):
+                    data = line[6:]
+                    if data == '[DONE]':
+                        break
+                    try:
+                        parsed = json.loads(data)
+                        content = parsed['choices'][0]['delta'].get('content')
+                        if content:
+                            yield content
+                    except:
+                        continue
+
+    def solve_math_problem(self, problem: str, show_steps: bool = True) -> Dict[str, Any]:
+        """Solve with steps"""
+        system_prompt = f"""Eres un asistente matemático experto.
+        Resuelve el problema {'mostrando pasos' if show_steps else 'directamente'}.
+        Responde en JSON:
+        {{
+          "solution": "Respuesta LaTeX",
+          "steps": ["Paso 1"],
+          "reasoning": "...",
+          "concepts": []
+        }}"""
+        
+        messages = [
+             {'role': 'system', 'content': system_prompt},
+             {'role': 'user', 'content': problem}
+        ]
+        
+        content = self.chat(messages, temperature=0.3)
+        try:
+             if content.startswith("```json"):
+                content = content.replace("```json", "").replace("```", "")
+             return json.loads(content)
+        except:
+             return {"solution": content, "steps": [], "reasoning": "Raw output", "concepts": []}
+
+    def explain_concept(self, concept: str, level: str = 'intermediate') -> str:
+        """Explain concept"""
+        system_prompt = f"""Explica {concept} para nivel {level}. Usa Markdown."""
+        messages = [
+            {'role': 'system', 'content': system_prompt},
+            {'role': 'user', 'content': 'Explícalo'}
+        ]
+        return self.chat(messages, temperature=0.5)
+
+    def generate_exercises(self, topic: str, count: int = 5, difficulty: str = 'medium') -> List[Dict[str, Any]]:
+        """Generate exercises"""
+        system_prompt = f"""Genera {count} ejercicios de {topic} ({difficulty}).
+        Responde en JSON: [{{ "problem": "...", "solution": "...", "steps": [] }}]"""
+        
+        messages = [{'role': 'system', 'content': system_prompt}, {'role': 'user', 'content': 'Generar'}]
+        content = self.chat(messages)
+        try:
+            if content.startswith("```json"): content = content.replace("```json", "").replace("```","")
+            return json.loads(content)
+        except:
+            return []
+
+# Singleton
+kimi_service = KimiService()

binary_equalab/sonify.py

@@ -3,6 +3,7 @@ import numpy as np
 import wave
 import struct
 import os
+import re
 from typing import Union, List
 import sympy as sp
 from .parser_enhanced import EnhancedParser
@@ -27,9 +28,23 @@ class AudioEngine:
         
         # Preprocess using our EnhancedParser (supports 2t, sin^2(t))
         clean_expr = EnhancedParser.preprocess(expr_str)
+        # Custom replacements for Sonify (since it doesn't use Engine's full pipeline)
+        replacements = {
+            'seno': 'sin', 'sen': 'sin',
+            'coseno': 'cos', 'tangente': 'tan',
+            'raiz': 'sqrt'
+        }
+        for es, en in replacements.items():
+            clean_expr = re.sub(rf'\b{es}\b', en, clean_expr, flags=re.IGNORECASE)
+            
         # Also standardize python power
         clean_expr = clean_expr.replace('^', '**')
         
+        # Smart variable replacement: if users type 'sin(x)', they mean 'sin(t)' for audio
+        if 'x' in clean_expr and 't' not in clean_expr:
+            print("ℹ️ Auto-detecting 'x' as time variable...")
+            clean_expr = clean_expr.replace('x', 't')
+        
         try:
             # Parse with SymPy
             sym_expr = sp.sympify(clean_expr)

binary_equalab/tui.py

@@ -0,0 +1,252 @@
+from textual.app import App, ComposeResult
+from textual.widgets import Header, Footer, Input, RichLog, Static
+from textual.containers import Container
+from textual import on, events
+from textual.suggester import Suggester
+from sympy import pretty
+from .engine import MathEngine
+
+class MathSuggester(Suggester):
+    """Basic auto-complete for math commands."""
+    def __init__(self):
+        super().__init__(use_cache=False)
+        self.suggestions = [
+            "derivar(", "integrar(", "limite(", "sumatoria(", 
+            "simplificar(", "expandir(", "factorizar(", "resolver(",
+            "sonify(", "distancia(", "recta(", "circulo(",
+            "sin(", "cos(", "tan(", "sqrt(", "log(",
+            "matrix(", "help", "clear", "exit", "quit"
+        ]
+        
+    async def get_suggestion(self, value: str) -> str | None:
+        if not value: 
+            return None
+        # Simple prefix match
+        word = value.split(" ")[-1] # last word
+        if not word: return None
+        
+        for s in self.suggestions:
+            if s.startswith(word) and s != word:
+                # Return the ending part to complete the word
+                return s[len(word):]
+        return None
+
+class BinaryTUI(App):
+    """A Textual App for Binary EquaLab (Jupyter-Lite Style)."""
+    
+    CSS = """
+    Screen {
+        layout: vertical;
+        background: #0f172a; /* Slate 900 */
+    }
+    
+    RichLog {
+        background: #1e293b; /* Slate 800 */
+        color: #e2e8f0; /* Slate 200 */
+        border: none;
+        height: 1fr;
+        padding: 1;
+        scrollbar-background: #0f172a;
+        scrollbar-color: #3b82f6;
+    }
+    
+    Input {
+        dock: bottom;
+        margin: 0;
+        border: wide #3b82f6; /* Blue 500 */
+        background: #0f172a;
+        color: #fb923c; /* Orange 400 */
+        height: 3;
+    }
+    
+    #welcome {
+        color: #fb923c;
+        text-style: bold;
+        text-align: center;
+        background: #0f172a;
+        padding: 1;
+        border-bottom: solid #3b82f6;
+    }
+    
+    .in-prompt {
+        color: #38bdf8; /* Sky 400 */
+        text-style: bold;
+    }
+    
+    .out-prompt {
+        color: #fb923c; /* Orange 400 */
+        text-style: bold;
+    }
+    
+    #help-bar {
+        background: #0f172a;
+        color: #94a3b8; /* Slate 400 */
+        padding-left: 1;
+        height: 1;
+        dock: bottom; /* Sit right above the input */
+    }
+    """
+
+    BINDINGS = [
+        ("ctrl+q", "quit", "Quit"),
+        ("ctrl+c", "copy_or_ignore", "Copy/Ignore"), # Prevent accidental exit
+        ("ctrl+l", "clear_screen", "Clear"),
+    ]
+
+    def action_copy_or_ignore(self) -> None:
+        """Handle Ctrl+C safely."""
+        self.notify("Usa Ctrl+Q o escribe 'exit' para salir.", title="No te vayas aún...", severity="warning")
+
+    def __init__(self):
+        super().__init__()
+        self.engine = MathEngine()
+        self.history = []
+        self.history_index = -1
+        self.execution_count = 1
+
+    # Help Dictionary for Contextual Hints
+    HELP_DOCS = {
+        "derivar": "💡 derivar(expr, var) - Calcula la derivada. Ej: derivar(x^2, x)",
+        "integrar": "💡 integrar(expr, var, [a, b]) - Integral indefinida o definida. Ej: integrar(sin(x), x)",
+        "limite": "💡 limite(expr, var, punto) - Calcula el límite. Ej: limite(sin(x)/x, x, 0)",
+        "sumatoria": "💡 sumatoria(expr, var, a, b) - Suma de a hasta b. Ej: sumatoria(n^2, n, 1, 10)",
+        "simplificar": "💡 simplificar(expr) - Reduce la expresión. Ej: simplificar((x^2-1)/(x-1))",
+        "expandir": "💡 expandir(expr) - Expande polinomios. Ej: expandir((x+1)^2)",
+        "factorizar": "💡 factorizar(expr) - Factoriza polinomios. Ej: factorizar(x^2 - 1)",
+        "resolver": "💡 resolver(expr, var) - Encuentra las raíces. Ej: resolver(x^2 - 4, x)",
+        "sonify": "💡 sonify(expr) - Genera y reproduce audio. Ej: sonify(sin(440*2*pi*t))",
+        "distancia": "💡 distancia(p1, p2) - Distancia Euclidiana. Ej: distancia((0,0), (3,4))",
+        "matrix": "💡 matrix([[a,b],[c,d]]) - Crea una matriz. Ej: matrix([[1,2],[3,4]])",
+        "help": "💡 presiona Enter para ver la ayuda completa.",
+        "clear": "💡 Limpia la pantalla.",
+    }
+
+    def compose(self) -> ComposeResult:
+        """Compose the UI."""
+        yield Header(show_clock=True)
+        yield Static("Binary EquaLab PRO terminal", id="welcome")
+        yield RichLog(id="output", markup=True, wrap=True)
+        yield Static("", id="help-bar") # New Help Bar
+        yield Input(
+            placeholder=">>> Escribe una expresión (ej. integrate(x^2))...", 
+            id="input",
+            suggester=MathSuggester()
+        )
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Called when app starts."""
+        self.title = "Binary EquaLab TUI"
+        log = self.query_one(RichLog)
+        log.write("[bold green]System Ready.[/] Type 'help' for commands.")
+        log.write("[dim italic]Consejo: Usa 'sonify(sin(440*t))' para escuchar ecuaciones.[/dim italic]")
+
+    @on(Input.Changed)
+    def handle_input_change(self, event: Input.Changed) -> None:
+        """Update help bar based on input."""
+        val = event.value.strip().lower()
+        help_bar = self.query_one("#help-bar", Static)
+        
+        # Simple prefix check
+        found = False
+        for cmd, doc in self.HELP_DOCS.items():
+            if val.startswith(cmd):
+                help_bar.update(doc)
+                help_bar.styles.color = "#38bdf8" # Sky blue
+                found = True
+                break
+        
+        if not found:
+            help_bar.update("")
+
+    @on(Input.Submitted)
+    def handle_input(self, event: Input.Submitted) -> None:
+        """Handle input submission."""
+        command = event.value.strip()
+        if not command:
+            return
+            
+        log = self.query_one(RichLog)
+        input_widget = self.query_one(Input)
+        help_bar = self.query_one("#help-bar", Static)
+        
+        # Clear help
+        help_bar.update("")
+        
+        # Add to local history
+        self.history.append(command)
+        self.history_index = len(self.history)
+        
+        # Echo Input (Jupyter style)
+        count = self.execution_count
+        log.write(f"\n[bold blue]In [{count}]:[/] [white]{command}[/]")
+        
+        # Clear input
+        input_widget.value = ""
+        
+        if command.lower() in ('exit', 'quit'):
+            self.exit()
+            return
+            
+        if command.lower() == 'clear':
+            log.clear()
+            return
+
+        # Process logic
+        try:
+            result = self.engine.evaluate(command)
+            
+            if result is not None:
+                # Pretty print result (ASCII/Unicode Art)
+                pretty_result = pretty(result, use_unicode=True)
+                
+                # Check for audio file output (Sonify)
+                if isinstance(result, str) and result.endswith('.wav'):
+                    import os
+                    import platform
+                    if platform.system() == "Windows":
+                        # Auto-play on Windows
+                        try:
+                            os.startfile(result)
+                            log.write("[bold green]🎵 Reproduciendo audio...[/]")
+                        except Exception as e:
+                            log.write(f"[bold red]Error reproduciendo audio: {e}[/]")
+                
+                # Format output
+                log.write(f"[bold orange1]Out[{count}]:[/]")
+                log.write(pretty_result)
+                
+        except Exception as e:
+            log.write(f"[bold red]Error:[/bold red] {e}")
+            
+        self.execution_count += 1
+
+    def on_key(self, event: events.Key) -> None:
+        """Handle global key events for history navigation."""
+        input_widget = self.query_one(Input)
+        
+        if not self.history:
+            return
+
+        if event.key == "up":
+            self.history_index = max(0, self.history_index - 1)
+            if self.history_index < len(self.history):
+                input_widget.value = self.history[self.history_index]
+                input_widget.cursor_position = len(input_widget.value)
+                event.stop() # Prevent default behavior
+                
+        elif event.key == "down":
+            self.history_index = min(len(self.history), self.history_index + 1)
+            if self.history_index < len(self.history):
+                input_widget.value = self.history[self.history_index]
+            else:
+                input_widget.value = ""
+            input_widget.cursor_position = len(input_widget.value)
+            event.stop()
+
+    def action_clear_screen(self) -> None:
+        self.query_one(RichLog).clear()
+
+if __name__ == "__main__":
+    app = BinaryTUI()
+    app.run()

{binary_equalab-3.0.0b1.dist-info → binary_equalab-3.0.0b3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: binary-equalab
-Version: 3.0.0b1
+Version: 3.0.0b3
 Summary: Binary Equalab is a symbolic mathematics toolkit focused on clarity, performance and educational value. Designed for students, engineers and curious minds who want math to feel alive.
 Project-URL: Homepage, https://github.com/AldrasTeam/BinaryEquaLab
 Project-URL: Repository, https://github.com/AldrasTeam/BinaryEquaLab
@@ -26,6 +26,7 @@ Requires-Dist: requests>=2.31.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: scipy>=1.10.0
 Requires-Dist: sympy>=1.12
+Requires-Dist: textual>=0.40.0
 Requires-Dist: typer>=0.9.0
 Provides-Extra: dev
 Requires-Dist: black>=23.0; extra == 'dev'
@@ -91,7 +92,21 @@ Soporta:
 
 ## 🚀 Uso del CLI
 
-### REPL Mode
+### 🎮 Interactive TUI (Nuevo v3.0)
+La nueva interfaz inmersiva tipo "Jupyter-Lite".
+
+```bash
+binary-math tui
+```
+
+**Features:**
+-   ✨ **Autocompletado & Hints:** Escribe y recibe ayuda contextual.
+-   🎹 **Sonificación:** `sonify(sin(440*t))` reproduce el audio automáticamente.
+-   📜 **Historial:** Navega con ↑ / ↓.
+-   🖥️ **Pretty Print:** Ecuaciones renderizadas con Unicode.
+
+### Rápido REPL Mode
+Para consultas rápidas sin interfaz gráfica:
 ```bash
 binary-math
 ```

binary_equalab-3.0.0b3.dist-info/RECORD

@@ -0,0 +1,16 @@
+binary_equalab/__init__.py,sha256=WFF_aioc3t6xkz0qU_RI4FeqY4UT92c8wE5cDDJWenY,675
+binary_equalab/cli.py,sha256=XQ-PDw8KfQfkaUr7kjG_fNXObMp9IKk9CAeauS6kQG8,12510
+binary_equalab/engine.py,sha256=0ZC6QcTmEKuKl0GEFioj5BR1wK0e7P8_F1W20F0zk9s,17474
+binary_equalab/functions.py,sha256=F6GPCXoScCHVZ4CDEE2Rns5i3x89DAcKRVBte88j9oE,569
+binary_equalab/geometry.py,sha256=YPn59oQtTY_hb4LZyIEJUvN1pWJz_y5uk8gVBio1Gwo,2217
+binary_equalab/giac_poc.py,sha256=_XdxE2lrvFH7M6qDfzSQHRdplxPzKhKfIWAcsOQq8Ho,2226
+binary_equalab/kimi_service.py,sha256=wofChDT1tB9lN72jwC6DcMdd8Xg2VfbJj2Mt5seQ-R0,5491
+binary_equalab/parser_enhanced.py,sha256=P7oMnGHWn3xoqVChkPJ6B_i_IR9TeJMJXBjKoCO13ts,2735
+binary_equalab/shell_setup.py,sha256=9Ax_QcHEAopYIjShuBaHglg4HPysXJKbNL3D_FjexrU,4518
+binary_equalab/sonify.py,sha256=6SUVzfVB4A78Elr-6tz9KxGLp1C0KbslAaTOkkavUNE,3954
+binary_equalab/tui.py,sha256=ZID98jgy4upEUxLjeRAPmP_VUbcmspMkII_hawTHZcc,9140
+binary_equalab/services/kimi_service.py,sha256=rhEWWbw2NG-bBQR5STZi7MQuJzRNW4qmMBEc-FLic-k,4594
+binary_equalab-3.0.0b3.dist-info/METADATA,sha256=qIZnHv4uJXFHBk18N5yxuqeBzLiuLG-69mSoApX9514,5845
+binary_equalab-3.0.0b3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+binary_equalab-3.0.0b3.dist-info/entry_points.txt,sha256=2Io1Wi069dvgPHmGXmAT1a6rNA-DIq7tChai69jtbF0,119
+binary_equalab-3.0.0b3.dist-info/RECORD,,

binary_equalab-3.0.0b1.dist-info/RECORD

@@ -1,14 +0,0 @@
-binary_equalab/__init__.py,sha256=WFF_aioc3t6xkz0qU_RI4FeqY4UT92c8wE5cDDJWenY,675
-binary_equalab/cli.py,sha256=kEA7Vw3gQZrRJJRFxDppqUo253jem424ZuczIwEjz60,12219
-binary_equalab/engine.py,sha256=WhkKpdDCg2zqH9cMXDPMQ7Ut7Awyn4WzkVrRVP7_dtE,15931
-binary_equalab/functions.py,sha256=F6GPCXoScCHVZ4CDEE2Rns5i3x89DAcKRVBte88j9oE,569
-binary_equalab/geometry.py,sha256=YPn59oQtTY_hb4LZyIEJUvN1pWJz_y5uk8gVBio1Gwo,2217
-binary_equalab/giac_poc.py,sha256=_XdxE2lrvFH7M6qDfzSQHRdplxPzKhKfIWAcsOQq8Ho,2226
-binary_equalab/kimi_service.py,sha256=wofChDT1tB9lN72jwC6DcMdd8Xg2VfbJj2Mt5seQ-R0,5491
-binary_equalab/parser_enhanced.py,sha256=P7oMnGHWn3xoqVChkPJ6B_i_IR9TeJMJXBjKoCO13ts,2735
-binary_equalab/shell_setup.py,sha256=9Ax_QcHEAopYIjShuBaHglg4HPysXJKbNL3D_FjexrU,4518
-binary_equalab/sonify.py,sha256=HfAYPtXLRyb3miLBsd8liqk4D5hvXVBHEEyV6fj9Za8,3274
-binary_equalab-3.0.0b1.dist-info/METADATA,sha256=is9DrY6iTKa1t6Z38P2SvgFbGfvzND3BhCWWGyP7_Jw,5357
-binary_equalab-3.0.0b1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-binary_equalab-3.0.0b1.dist-info/entry_points.txt,sha256=2Io1Wi069dvgPHmGXmAT1a6rNA-DIq7tChai69jtbF0,119
-binary_equalab-3.0.0b1.dist-info/RECORD,,