nexuscalc 1.0.0__tar.gz

nexuscalc-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Light Bulb Experiments
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nexuscalc-1.0.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.1
+Name: nexuscalc
+Version: 1.0.0
+Summary: A powerful calculator application with an interactive CLI
+Home-page: https://github.com/yourusername/nexuscalc
+Author: NexusCalc Team
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# NexusCalc
+
+A powerful calculator application with an interactive command-line interface.
+
+## Features
+
+- ➕ Addition
+- ➖ Subtraction
+- ✖️ Multiplication
+- ➗ Division with zero division error handling
+- 🏠 Floor division
+- 🔢 Mathematical constants (pi, e, tau)
+- 📐 Advanced mathematical functions (sqrt, sin, cos, tan, log)
+- 🛡️ Comprehensive error handling
+- 💎 Clean number formatting
+- 🎨 Colorful and interactive CLI
+
+## Installation
+
+```bash
+python -m pip install nexuscalc
+```
+
+## Usage
+
+### Interactive Mode
+
+```python
+from nexuscalc import nexuscalc
+nexuscalc.calculate()
+```
+
+Or:
+
+```python
+import nexuscalc
+nexuscalc.nexuscalc.calculate()
+```
+
+Or after installation:
+
+```bash
+nexuscalc
+```
+
+### Programmatic Usage
+
+```python
+from nexuscalc.core.operations import Operations
+
+ops = Operations()
+result = ops.add(5, 3)  # Returns 8
+```
+
+### Advanced Expression Evaluation
+
+```python
+from nexuscalc.evaluator.evaluator import Evaluator
+
+eval = Evaluator()
+result = eval.evaluate_expression("2 + 3 * 4")  # Returns 14
+```
+
+## Error Handling
+
+NexusCalc includes comprehensive error handling for:
+
+- Division by zero (with friendly error messages)
+- Invalid input formats
+- Numeric overflow
+- Expression parsing errors
+- Function evaluation errors
+
+## Development
+
+Run tests:
+
+```bash
+python -m pytest tests/ -v
+```
+
+Run tests with coverage:
+
+```bash
+python -m pytest tests/ --cov=src/nexuscalc
+```
+
+## Project Structure
+
+```
+nexuscalc/
+├── src/nexuscalc/
+│   ├── core/          # Core calculator logic
+│   ├── parsers/       # Expression parsing
+│   ├── evaluator/     # Expression evaluation
+│   ├── utils/         # Utilities and helpers
+│   └── exceptions/    # Custom exceptions
+├── tests/             # Unit tests
+├── examples/          # Usage examples
+└── setup.py          # Package setup
+```
+
+## License
+
+MIT
+
+## Author
+
+Light Bulb Experiments © 2026
+
+

nexuscalc-1.0.0/README.md

@@ -0,0 +1,109 @@
+# NexusCalc
+
+A powerful calculator application with an interactive command-line interface.
+
+## Features
+
+- ➕ Addition
+- ➖ Subtraction
+- ✖️ Multiplication
+- ➗ Division with zero division error handling
+- 🏠 Floor division
+- 🔢 Mathematical constants (pi, e, tau)
+- 📐 Advanced mathematical functions (sqrt, sin, cos, tan, log)
+- 🛡️ Comprehensive error handling
+- 💎 Clean number formatting
+- 🎨 Colorful and interactive CLI
+
+## Installation
+
+```bash
+python -m pip install nexuscalc
+```
+
+## Usage
+
+### Interactive Mode
+
+```python
+from nexuscalc import nexuscalc
+nexuscalc.calculate()
+```
+
+Or:
+
+```python
+import nexuscalc
+nexuscalc.nexuscalc.calculate()
+```
+
+Or after installation:
+
+```bash
+nexuscalc
+```
+
+### Programmatic Usage
+
+```python
+from nexuscalc.core.operations import Operations
+
+ops = Operations()
+result = ops.add(5, 3)  # Returns 8
+```
+
+### Advanced Expression Evaluation
+
+```python
+from nexuscalc.evaluator.evaluator import Evaluator
+
+eval = Evaluator()
+result = eval.evaluate_expression("2 + 3 * 4")  # Returns 14
+```
+
+## Error Handling
+
+NexusCalc includes comprehensive error handling for:
+
+- Division by zero (with friendly error messages)
+- Invalid input formats
+- Numeric overflow
+- Expression parsing errors
+- Function evaluation errors
+
+## Development
+
+Run tests:
+
+```bash
+python -m pytest tests/ -v
+```
+
+Run tests with coverage:
+
+```bash
+python -m pytest tests/ --cov=src/nexuscalc
+```
+
+## Project Structure
+
+```
+nexuscalc/
+├── src/nexuscalc/
+│   ├── core/          # Core calculator logic
+│   ├── parsers/       # Expression parsing
+│   ├── evaluator/     # Expression evaluation
+│   ├── utils/         # Utilities and helpers
+│   └── exceptions/    # Custom exceptions
+├── tests/             # Unit tests
+├── examples/          # Usage examples
+└── setup.py          # Package setup
+```
+
+## License
+
+MIT
+
+## Author
+
+Light Bulb Experiments © 2026

nexuscalc-1.0.0/setup.cfg

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

nexuscalc-1.0.0/setup.py

@@ -0,0 +1,29 @@
+"""Setup configuration for NexusCalc."""
+
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="nexuscalc",
+    version="1.0.0",
+    author="NexusCalc Team",
+    description="A powerful calculator application with an interactive CLI",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourusername/nexuscalc",
+    package_dir={"": "src"},
+    packages=find_packages(where="src"),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.6",
+    entry_points={
+        "console_scripts": [
+            "nexuscalc=nexuscalc:calculate",
+        ],
+    },
+)

nexuscalc-1.0.0/src/nexuscalc/__init__.py

@@ -0,0 +1,23 @@
+"""NexusCalc - A powerful calculator application."""
+
+from .core.calculator import NexusCalc
+
+__version__ = "1.0.0"
+__all__ = ["NexusCalc", "calculate", "nexuscalc"]
+
+def calculate():
+    """Main entry point for the calculator."""
+    calc = NexusCalc()
+    calc.run()
+
+# Create a class that matches the module name for nexuscalc.nexuscalc.calculate()
+class nexuscalc:
+    """Wrapper class for nexuscalc.nexuscalc.calculate() compatibility."""
+    @staticmethod
+    def calculate():
+        """Main entry point for the calculator."""
+        calc = NexusCalc()
+        calc.run()
+
+# Also expose NexusCalc as a class
+NexusCalc = NexusCalc

nexuscalc-1.0.0/src/nexuscalc/core/__init__.py

@@ -0,0 +1 @@
+"""Core calculator module."""

nexuscalc-1.0.0/src/nexuscalc/core/calculator.py

@@ -0,0 +1,140 @@
+"""Main calculator implementation."""
+
+import sys
+import re
+from ..core.operations import Operations
+from ..utils.validators import validate_number
+from ..utils.formatters import format_result
+from ..exceptions.calculator_errors import CalculatorError, DivisionByZeroError
+
+class NexusCalc:
+    """Main calculator class with interactive menu."""
+    
+    def __init__(self):
+        self.operations = Operations()
+        self.running = True
+        self.menu_options = {
+            '1': ('Add', self.operations.add),
+            '2': ('Subtract', self.operations.subtract),
+            '3': ('Multiply', self.operations.multiply),
+            '4': ('Divide', self.operations.divide),
+            '5': ('Floor', self.operations.floor_divide),
+        }
+        # Regex patterns for quit commands
+        self.quit_patterns = [
+            re.compile(r'^[Qq]$'),           # q or Q
+            re.compile(r'^[Qq][Uu][Ii][Tt]$'), # quit in any case
+            re.compile(r'^6$'),               # number 6
+        ]
+    
+    def is_quit_command(self, text):
+        """Check if the input matches any quit pattern."""
+        if not text:
+            return False
+        text = text.strip()
+        for pattern in self.quit_patterns:
+            if pattern.match(text):
+                return True
+        return False
+    
+    def run(self):
+        """Run the calculator main loop."""
+        try:
+            while self.running:
+                try:
+                    self.show_menu()
+                    choice = self.get_input("Use 1-5").strip().lower()
+                    
+                    # Check if it's a quit command using regex
+                    if self.is_quit_command(choice):
+                        print("\n👋 Goodbye! Thanks for using NexusCalc!")
+                        self.running = False
+                        break
+                    
+                    if choice not in self.menu_options:
+                        print("❌ Invalid choice. Please select 1-5 or 6/q/quit to exit.")
+                        continue
+                    
+                    operation_name, operation_func = self.menu_options[choice]
+                    
+                    try:
+                        num1 = self.get_number("Enter first number")
+                        num2 = self.get_number("Enter second number")
+                        
+                        result = operation_func(num1, num2)
+                        print(f"\n✅ Result: {format_result(result)}")
+                        
+                    except DivisionByZeroError as e:
+                        print(f"\n❌ Division Error: {e}")
+                        print("💡 Hint: You cannot divide by zero. Please try a different number.")
+                    except CalculatorError as e:
+                        print(f"\n❌ Error: {e}")
+                    except ValueError:
+                        print("\n❌ Error: Invalid number format. Please enter a valid number.")
+                    except Exception as e:
+                        print(f"\n❌ Unexpected error: {e}")
+                    
+                    print()
+                    
+                except KeyboardInterrupt:
+                    print("\n\n⚠️ Operation cancelled by user.")
+                    print("💡 Press Ctrl+C again to exit, or continue using the calculator.")
+                    continue
+                except EOFError:
+                    print("\n\n⚠️ Input stream closed.")
+                    print("💡 Exiting calculator...")
+                    self.running = False
+                    break
+                
+        except KeyboardInterrupt:
+            print("\n\n👋 Goodbye! Calculator exited.")
+            sys.exit(0)
+        except Exception as e:
+            print(f"\n❌ Fatal error: {e}")
+            sys.exit(1)
+    
+    def show_menu(self):
+        """Display the main menu."""
+        print("\n" + "="*50)
+        print("🔢 NEXUSCALC - Powerful Calculator")
+        print("="*50)
+        print("\nWhat are you trying to calculate?")
+        print("List:")
+        print()
+        print("1. Add ➕")
+        print("2. Subtract ➖")
+        print("3. Multiply ✖️")
+        print("4. Divide ➗")
+        print("5. Floor 🏠")
+        print("6. Quit 🚪")
+        print()
+        print("💡 Press Ctrl+C to cancel operation")
+        print("💡 Type '6', 'q', 'Q', 'quit', or 'QUIT' to exit")
+        print("-"*50)
+    
+    def get_input(self, prompt):
+        """Get user input with NEXUSCALC > prompt."""
+        try:
+            return input(f"{prompt}\nNEXUSCALC > ")
+        except KeyboardInterrupt:
+            print("\n\n⚠️ Input cancelled.")
+            raise
+        except EOFError:
+            print("\n\n⚠️ End of input detected.")
+            raise
+    
+    def get_number(self, prompt):
+        """Get and validate a number from user input."""
+        while True:
+            try:
+                user_input = self.get_input(prompt)
+                return validate_number(user_input)
+            except CalculatorError as e:
+                print(f"❌ Error: {e}")
+                print("💡 Please try again with a valid number.")
+            except KeyboardInterrupt:
+                print("\n⚠️ Number input cancelled.")
+                raise
+            except EOFError:
+                print("\n⚠️ End of input detected.")
+                raise

nexuscalc-1.0.0/src/nexuscalc/core/constants.py

@@ -0,0 +1,30 @@
+"""Mathematical constants."""
+
+import math
+
+class Constants:
+    """Collection of mathematical constants."""
+    
+    PI = math.pi
+    E = math.e
+    TAU = math.tau
+    INF = float('inf')
+    NAN = float('nan')
+    
+    @classmethod
+    def get_constant(cls, name):
+        """Get a constant by name."""
+        constants = {
+            'pi': cls.PI,
+            'e': cls.E,
+            'tau': cls.TAU,
+            'inf': cls.INF,
+            'infinity': cls.INF,
+            'nan': cls.NAN
+        }
+        return constants.get(name.lower())
+    
+    @classmethod
+    def list_constants(cls):
+        """List all available constants."""
+        return ['pi', 'e', 'tau', 'inf', 'nan']

nexuscalc-1.0.0/src/nexuscalc/core/operations.py

@@ -0,0 +1,55 @@
+"""Mathematical operations with proper error handling."""
+
+from ..exceptions.calculator_errors import DivisionByZeroError, CalculatorError
+
+class Operations:
+    """Collection of mathematical operations."""
+    
+    @staticmethod
+    def add(a, b):
+        """Add two numbers."""
+        return a + b
+    
+    @staticmethod
+    def subtract(a, b):
+        """Subtract b from a."""
+        return a - b
+    
+    @staticmethod
+    def multiply(a, b):
+        """Multiply two numbers."""
+        return a * b
+    
+    @staticmethod
+    def divide(a, b):
+        """Divide a by b with zero division handling."""
+        if b == 0:
+            raise DivisionByZeroError("Cannot divide by zero!")
+        if a == 0:
+            return 0.0
+        return a / b
+    
+    @staticmethod
+    def floor_divide(a, b):
+        """Floor divide a by b with zero division handling."""
+        if b == 0:
+            raise DivisionByZeroError("Cannot floor divide by zero!")
+        if a == 0:
+            return 0
+        return a // b
+    
+    @staticmethod
+    def safe_divide(a, b):
+        """Safe division that returns None on error instead of raising."""
+        try:
+            return a / b
+        except ZeroDivisionError:
+            return None
+    
+    @staticmethod
+    def safe_floor_divide(a, b):
+        """Safe floor division that returns None on error instead of raising."""
+        try:
+            return a // b
+        except ZeroDivisionError:
+            return None

nexuscalc-1.0.0/src/nexuscalc/evaluator/__init__.py

@@ -0,0 +1 @@
+"""Evaluator modules."""

nexuscalc-1.0.0/src/nexuscalc/evaluator/evaluator.py

@@ -0,0 +1,81 @@
+"""Expression evaluator for advanced calculations."""
+
+import math
+from ..exceptions.calculator_errors import EvaluationError, DivisionByZeroError
+from ..parsers.ast_nodes import NumberNode, BinOpNode, UnaryOpNode, FunctionNode, ConstantNode
+from ..core.constants import Constants
+
+class Evaluator:
+    """Evaluate parsed expressions."""
+    
+    def __init__(self):
+        self.constants = Constants()
+        self.functions = {
+            'sqrt': math.sqrt,
+            'sin': math.sin,
+            'cos': math.cos,
+            'tan': math.tan,
+            'log': math.log,
+            'abs': abs,
+            'ceil': math.ceil,
+            'floor': math.floor,
+            'round': round,
+        }
+    
+    def evaluate(self, ast):
+        """Evaluate an AST and return the result."""
+        if isinstance(ast, NumberNode):
+            return ast.value
+        
+        elif isinstance(ast, BinOpNode):
+            left_val = self.evaluate(ast.left)
+            right_val = self.evaluate(ast.right)
+            
+            if ast.operator == '+':
+                return left_val + right_val
+            elif ast.operator == '-':
+                return left_val - right_val
+            elif ast.operator == '*':
+                return left_val * right_val
+            elif ast.operator == '/':
+                if right_val == 0:
+                    raise DivisionByZeroError("Division by zero in expression")
+                return left_val / right_val
+            elif ast.operator == '//':
+                if right_val == 0:
+                    raise DivisionByZeroError("Floor division by zero in expression")
+                return left_val // right_val
+            else:
+                raise EvaluationError(f"Unknown binary operator: {ast.operator}")
+        
+        elif isinstance(ast, UnaryOpNode):
+            operand_val = self.evaluate(ast.operand)
+            if ast.operator == '-':
+                return -operand_val
+            elif ast.operator == '+':
+                return +operand_val
+            else:
+                raise EvaluationError(f"Unknown unary operator: {ast.operator}")
+        
+        elif isinstance(ast, FunctionNode):
+            args = [self.evaluate(arg) for arg in ast.args]
+            if ast.name in self.functions:
+                try:
+                    return self.functions[ast.name](*args)
+                except Exception as e:
+                    raise EvaluationError(f"Error evaluating function {ast.name}: {e}")
+            else:
+                raise EvaluationError(f"Unknown function: {ast.name}")
+        
+        elif isinstance(ast, ConstantNode):
+            return ast.value
+        
+        else:
+            raise EvaluationError(f"Unknown AST node type: {type(ast)}")
+    
+    def evaluate_expression(self, expression):
+        """Convenience method to parse and evaluate an expression."""
+        from ..parsers.expression_parser import ExpressionParser
+        parser = ExpressionParser()
+        ast = parser.parse(expression)
+        return self.evaluate(ast)

nexuscalc-1.0.0/src/nexuscalc/evaluator/functions.py

@@ -0,0 +1,124 @@
+"""Custom mathematical functions."""
+
+import math
+from functools import wraps
+from nexuscalc.exceptions.calculator_errors import CalculatorError
+
+class MathFunctions:
+    """Collection of mathematical functions."""
+    
+    @staticmethod
+    def sqrt(x):
+        """Square root."""
+        if x < 0:
+            raise CalculatorError("Cannot take square root of negative number")
+        return math.sqrt(x)
+    
+    @staticmethod
+    def sin(x):
+        """Sine in radians."""
+        return math.sin(x)
+    
+    @staticmethod
+    def cos(x):
+        """Cosine in radians."""
+        return math.cos(x)
+    
+    @staticmethod
+    def tan(x):
+        """Tangent in radians."""
+        return math.tan(x)
+    
+    @staticmethod
+    def log(x, base=math.e):
+        """Logarithm with specified base."""
+        if x <= 0:
+            raise CalculatorError("Logarithm only defined for positive numbers")
+        if base <= 0 or base == 1:
+            raise CalculatorError("Logarithm base must be positive and not equal to 1")
+        return math.log(x, base)
+    
+    @staticmethod
+    def log10(x):
+        """Base-10 logarithm."""
+        return MathFunctions.log(x, 10)
+    
+    @staticmethod
+    def log2(x):
+        """Base-2 logarithm."""
+        return MathFunctions.log(x, 2)
+    
+    @staticmethod
+    def exp(x):
+        """Exponential function e^x."""
+        return math.exp(x)
+    
+    @staticmethod
+    def pow(x, y):
+        """Power function x^y."""
+        return x ** y
+    
+    @staticmethod
+    def factorial(x):
+        """Factorial function."""
+        if x < 0:
+            raise CalculatorError("Factorial not defined for negative numbers")
+        if not isinstance(x, int) and x.is_integer():
+            x = int(x)
+        if not isinstance(x, int):
+            raise CalculatorError("Factorial only defined for integers")
+        return math.factorial(x)
+    
+    @staticmethod
+    def gcd(a, b):
+        """Greatest common divisor."""
+        return math.gcd(int(a), int(b))
+    
+    @staticmethod
+    def lcm(a, b):
+        """Least common multiple."""
+        return abs(a * b) // math.gcd(int(a), int(b))
+    
+    @staticmethod
+    def max(*args):
+        """Maximum value."""
+        return max(args)
+    
+    @staticmethod
+    def min(*args):
+        """Minimum value."""
+        return min(args)
+    
+    @staticmethod
+    def average(*args):
+        """Average value."""
+        if not args:
+            raise CalculatorError("At least one number required for average")
+        return sum(args) / len(args)
+    
+    @staticmethod
+    def sum(*args):
+        """Sum of numbers."""
+        return sum(args)
+    
+    @staticmethod
+    def product(*args):
+        """Product of numbers."""
+        result = 1
+        for arg in args:
+            result *= arg
+        return result
+    
+    @staticmethod
+    def is_prime(n):
+        """Check if number is prime."""
+        if n < 2:
+            return False
+        if n == 2:
+            return True
+        if n % 2 == 0:
+            return False
+        for i in range(3, int(math.sqrt(n)) + 1, 2):
+            if n % i == 0:
+                return False
+        return True

nexuscalc-1.0.0/src/nexuscalc/exceptions/__init__.py

@@ -0,0 +1 @@
+"""Exception modules."""

nexuscalc-1.0.0/src/nexuscalc/exceptions/calculator_errors.py

@@ -0,0 +1,27 @@
+"""Custom exceptions for the calculator."""
+
+class CalculatorError(Exception):
+    """Base exception for calculator errors."""
+    pass
+
+class DivisionByZeroError(CalculatorError):
+    """Exception raised when attempting to divide by zero."""
+    def __init__(self, message="Cannot divide by zero!"):
+        self.message = message
+        super().__init__(self.message)
+
+class ParserError(CalculatorError):
+    """Exception raised for parsing errors."""
+    pass
+
+class EvaluationError(CalculatorError):
+    """Exception raised for evaluation errors."""
+    pass
+
+class InvalidInputError(CalculatorError):
+    """Exception raised for invalid input."""
+    pass
+
+class OverflowError(CalculatorError):
+    """Exception raised for numeric overflow."""
+    pass

nexuscalc-1.0.0/src/nexuscalc/parsers/__init__.py

@@ -0,0 +1 @@
+"""Parser modules."""

nexuscalc-1.0.0/src/nexuscalc/parsers/ast_nodes.py

@@ -0,0 +1,63 @@
+"""AST nodes for parsed expressions."""
+
+from dataclasses import dataclass
+from typing import List, Any, Optional
+
+@dataclass
+class Token:
+    """Token representation."""
+    type: str
+    value: Any
+    position: int = 0
+    line: int = 1
+    col: int = 1
+
+class ASTNode:
+    """Base class for AST nodes."""
+    pass
+
+@dataclass
+class NumberNode(ASTNode):
+    """Node for numeric values."""
+    value: float
+    
+    def __str__(self):
+        return str(self.value)
+
+@dataclass
+class BinOpNode(ASTNode):
+    """Node for binary operations."""
+    operator: str
+    left: ASTNode
+    right: ASTNode
+    
+    def __str__(self):
+        return f"({self.left} {self.operator} {self.right})"
+
+@dataclass
+class UnaryOpNode(ASTNode):
+    """Node for unary operations."""
+    operator: str
+    operand: ASTNode
+    
+    def __str__(self):
+        return f"({self.operator}{self.operand})"
+
+@dataclass
+class FunctionNode(ASTNode):
+    """Node for function calls."""
+    name: str
+    args: List[ASTNode]
+    
+    def __str__(self):
+        args_str = ', '.join(str(arg) for arg in self.args)
+        return f"{self.name}({args_str})"
+
+@dataclass
+class ConstantNode(ASTNode):
+    """Node for constants like pi, e."""
+    name: str
+    value: float
+    
+    def __str__(self):
+        return self.name

nexuscalc-1.0.0/src/nexuscalc/parsers/expression_parser.py

@@ -0,0 +1,111 @@
+"""Expression parser for advanced calculations."""
+
+import re
+from ..exceptions.calculator_errors import ParserError
+from .tokenizer import Tokenizer
+from .ast_nodes import *
+
+class ExpressionParser:
+    """Parse mathematical expressions."""
+    
+    def __init__(self):
+        self.tokenizer = Tokenizer()
+        self.current_token = None
+        self.tokens = []
+        self.position = 0
+    
+    def parse(self, expression):
+        """Parse an expression string into an AST."""
+        if not expression or expression.strip() == '':
+            raise ParserError("Expression cannot be empty")
+        
+        self.tokens = self.tokenizer.tokenize(expression)
+        self.position = 0
+        
+        if not self.tokens:
+            raise ParserError("No valid tokens found in expression")
+        
+        self.current_token = self.tokens[0]
+        return self.parse_expression()
+    
+    def parse_expression(self):
+        """Parse an expression (addition/subtraction)."""
+        node = self.parse_term()
+        
+        while self.current_token and self.current_token.type in ('PLUS', 'MINUS'):
+            if self.current_token.type == 'PLUS':
+                self.advance()
+                right = self.parse_term()
+                node = BinOpNode('+', node, right)
+            elif self.current_token.type == 'MINUS':
+                self.advance()
+                right = self.parse_term()
+                node = BinOpNode('-', node, right)
+        
+        return node
+    
+    def parse_term(self):
+        """Parse a term (multiplication/division/floor)."""
+        node = self.parse_factor()
+        
+        while self.current_token and self.current_token.type in ('MULTIPLY', 'DIVIDE', 'FLOOR_DIVIDE'):
+            if self.current_token.type == 'MULTIPLY':
+                self.advance()
+                right = self.parse_factor()
+                node = BinOpNode('*', node, right)
+            elif self.current_token.type == 'DIVIDE':
+                self.advance()
+                right = self.parse_factor()
+                node = BinOpNode('/', node, right)
+            elif self.current_token.type == 'FLOOR_DIVIDE':
+                self.advance()
+                right = self.parse_factor()
+                node = BinOpNode('//', node, right)
+        
+        return node
+    
+    def parse_factor(self):
+        """Parse a factor (number, parenthesized expression, function call)."""
+        if not self.current_token:
+            raise ParserError("Unexpected end of expression")
+        
+        if self.current_token.type == 'NUMBER':
+            value = self.current_token.value
+            self.advance()
+            return NumberNode(value)
+        
+        elif self.current_token.type == 'LPAREN':
+            self.advance()
+            node = self.parse_expression()
+            if not self.current_token or self.current_token.type != 'RPAREN':
+                raise ParserError("Missing closing parenthesis")
+            self.advance()
+            return node
+        
+        elif self.current_token.type == 'FUNCTION':
+            func_name = self.current_token.value
+            self.advance()
+            if not self.current_token or self.current_token.type != 'LPAREN':
+                raise ParserError(f"Missing parenthesis after function '{func_name}'")
+            self.advance()
+            args = []
+            if self.current_token and self.current_token.type != 'RPAREN':
+                args.append(self.parse_expression())
+                while self.current_token and self.current_token.type == 'COMMA':
+                    self.advance()
+                    args.append(self.parse_expression())
+            if not self.current_token or self.current_token.type != 'RPAREN':
+                raise ParserError(f"Missing closing parenthesis for function '{func_name}'")
+            self.advance()
+            return FunctionNode(func_name, args)
+        
+        else:
+            raise ParserError(f"Unexpected token: {self.current_token.type}")
+    
+    def advance(self):
+        """Advance to the next token."""
+        self.position += 1
+        if self.position < len(self.tokens):
+            self.current_token = self.tokens[self.position]
+        else:
+            self.current_token = None

nexuscalc-1.0.0/src/nexuscalc/parsers/tokenizer.py

@@ -0,0 +1,52 @@
+"""Tokenizer for mathematical expressions."""
+
+import re
+from .ast_nodes import Token
+
+class Tokenizer:
+    """Convert expression string into tokens."""
+    
+    def __init__(self):
+        self.token_patterns = [
+            ('NUMBER', r'\d+\.?\d*'),
+            ('FUNCTION', r'(?:sqrt|sin|cos|tan|log|abs|ceil|floor|round)\b'),
+            ('PLUS', r'\+'),
+            ('MINUS', r'-'),
+            ('MULTIPLY', r'\*'),
+            ('DIVIDE', r'/'),
+            ('FLOOR_DIVIDE', r'//'),
+            ('LPAREN', r'\('),
+            ('RPAREN', r'\)'),
+            ('COMMA', r','),
+            ('WHITESPACE', r'\s+'),
+        ]
+        self.token_regex = re.compile(
+            '|'.join(f'(?P<{name}>{pattern})' for name, pattern in self.token_patterns)
+        )
+    
+    def tokenize(self, expression):
+        """Tokenize an expression string."""
+        tokens = []
+        position = 0
+        line = 1
+        col = 1
+        
+        for match in self.token_regex.finditer(expression):
+            token_type = match.lastgroup
+            value = match.group()
+            
+            if token_type == 'WHITESPACE':
+                # Count newlines for position tracking
+                lines = value.count('\n')
+                if lines > 0:
+                    line += lines
+                    col = len(value) - value.rfind('\n') - 1
+                else:
+                    col += len(value)
+                continue
+            
+            tokens.append(Token(token_type, value, position, line, col))
+            position += len(value)
+            col += len(value)
+        
+        return tokens

nexuscalc-1.0.0/src/nexuscalc/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility modules."""

nexuscalc-1.0.0/src/nexuscalc/utils/formatters.py

@@ -0,0 +1,64 @@
+"""Output formatting utilities."""
+
+import math
+
+def format_result(result):
+    """Format the result for display."""
+    if isinstance(result, float):
+        # Handle special values
+        if math.isnan(result):
+            return "NaN (Not a Number)"
+        if math.isinf(result):
+            return "Infinity" if result > 0 else "-Infinity"
+        
+        # Remove trailing zeros for cleaner display
+        if result.is_integer():
+            return str(int(result))
+        # Limit decimal places to 10
+        return f"{result:.10f}".rstrip('0').rstrip('.')
+    return str(result)
+
+def format_expression(operation, num1, num2, result):
+    """Format a complete mathematical expression."""
+    symbols = {
+        'add': '+',
+        'subtract': '-',
+        'multiply': '×',
+        'divide': '÷',
+        'floor': '//'
+    }
+    symbol = symbols.get(operation, '?')
+    return f"{format_result(num1)} {symbol} {format_result(num2)} = {format_result(result)}"
+
+def format_table(data, headers=None):
+    """Format data as a table."""
+    if not data:
+        return ""
+    
+    if headers:
+        rows = [headers] + data
+    else:
+        rows = data
+    
+    # Calculate column widths
+    col_widths = []
+    for col in range(len(rows[0])):
+        max_width = max(len(str(row[col])) for row in rows)
+        col_widths.append(max_width + 2)
+    
+    # Build table
+    result = []
+    for i, row in enumerate(rows):
+        line = "|"
+        for j, cell in enumerate(row):
+            line += f" {str(cell).ljust(col_widths[j] - 1)}|"
+        result.append(line)
+        
+        # Add header separator
+        if i == 0 and headers:
+            separator = "+"
+            for width in col_widths:
+                separator += "-" * width + "+"
+            result.insert(1, separator)
+    
+    return "\n".join(result)

nexuscalc-1.0.0/src/nexuscalc/utils/validators.py

@@ -0,0 +1,43 @@
+"""Input validation utilities."""
+
+import math
+from ..exceptions.calculator_errors import CalculatorError
+
+def validate_number(value):
+    """Validate and convert a string to a number (int or float)."""
+    if not value or value.strip() == '':
+        raise CalculatorError("Input cannot be empty")
+    
+    value = value.strip().lower()
+    
+    # Check for special values
+    if value in ['inf', 'infinity']:
+        return float('inf')
+    if value == '-inf':
+        return float('-inf')
+    if value in ['nan', 'not a number']:
+        return float('nan')
+    
+    try:
+        # Try int first
+        return int(value)
+    except ValueError:
+        try:
+            # Try float
+            return float(value)
+        except ValueError:
+            raise CalculatorError(f"'{value}' is not a valid number")
+    
+def is_valid_number(value):
+    """Check if a value is a valid number (not NaN or Infinity)."""
+    if isinstance(value, (int, float)):
+        return not (math.isnan(value) or math.isinf(value))
+    return False
+
+def is_integer(value):
+    """Check if a value is an integer."""
+    if isinstance(value, int):
+        return True
+    if isinstance(value, float):
+        return value.is_integer()
+    return False

nexuscalc-1.0.0/src/nexuscalc.egg-info/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.1
+Name: nexuscalc
+Version: 1.0.0
+Summary: A powerful calculator application with an interactive CLI
+Home-page: https://github.com/yourusername/nexuscalc
+Author: NexusCalc Team
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# NexusCalc
+
+A powerful calculator application with an interactive command-line interface.
+
+## Features
+
+- ➕ Addition
+- ➖ Subtraction
+- ✖️ Multiplication
+- ➗ Division with zero division error handling
+- 🏠 Floor division
+- 🔢 Mathematical constants (pi, e, tau)
+- 📐 Advanced mathematical functions (sqrt, sin, cos, tan, log)
+- 🛡️ Comprehensive error handling
+- 💎 Clean number formatting
+- 🎨 Colorful and interactive CLI
+
+## Installation
+
+```bash
+python -m pip install nexuscalc
+```
+
+## Usage
+
+### Interactive Mode
+
+```python
+from nexuscalc import nexuscalc
+nexuscalc.calculate()
+```
+
+Or:
+
+```python
+import nexuscalc
+nexuscalc.nexuscalc.calculate()
+```
+
+Or after installation:
+
+```bash
+nexuscalc
+```
+
+### Programmatic Usage
+
+```python
+from nexuscalc.core.operations import Operations
+
+ops = Operations()
+result = ops.add(5, 3)  # Returns 8
+```
+
+### Advanced Expression Evaluation
+
+```python
+from nexuscalc.evaluator.evaluator import Evaluator
+
+eval = Evaluator()
+result = eval.evaluate_expression("2 + 3 * 4")  # Returns 14
+```
+
+## Error Handling
+
+NexusCalc includes comprehensive error handling for:
+
+- Division by zero (with friendly error messages)
+- Invalid input formats
+- Numeric overflow
+- Expression parsing errors
+- Function evaluation errors
+
+## Development
+
+Run tests:
+
+```bash
+python -m pytest tests/ -v
+```
+
+Run tests with coverage:
+
+```bash
+python -m pytest tests/ --cov=src/nexuscalc
+```
+
+## Project Structure
+
+```
+nexuscalc/
+├── src/nexuscalc/
+│   ├── core/          # Core calculator logic
+│   ├── parsers/       # Expression parsing
+│   ├── evaluator/     # Expression evaluation
+│   ├── utils/         # Utilities and helpers
+│   └── exceptions/    # Custom exceptions
+├── tests/             # Unit tests
+├── examples/          # Usage examples
+└── setup.py          # Package setup
+```
+
+## License
+
+MIT
+
+## Author
+
+Light Bulb Experiments © 2026
+
+

nexuscalc-1.0.0/src/nexuscalc.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+LICENSE
+README.md
+setup.py
+src/nexuscalc/__init__.py
+src/nexuscalc.egg-info/PKG-INFO
+src/nexuscalc.egg-info/SOURCES.txt
+src/nexuscalc.egg-info/dependency_links.txt
+src/nexuscalc.egg-info/entry_points.txt
+src/nexuscalc.egg-info/top_level.txt
+src/nexuscalc/core/__init__.py
+src/nexuscalc/core/calculator.py
+src/nexuscalc/core/constants.py
+src/nexuscalc/core/operations.py
+src/nexuscalc/evaluator/__init__.py
+src/nexuscalc/evaluator/evaluator.py
+src/nexuscalc/evaluator/functions.py
+src/nexuscalc/exceptions/__init__.py
+src/nexuscalc/exceptions/calculator_errors.py
+src/nexuscalc/parsers/__init__.py
+src/nexuscalc/parsers/ast_nodes.py
+src/nexuscalc/parsers/expression_parser.py
+src/nexuscalc/parsers/tokenizer.py
+src/nexuscalc/utils/__init__.py
+src/nexuscalc/utils/formatters.py
+src/nexuscalc/utils/validators.py

nexuscalc-1.0.0/src/nexuscalc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nexuscalc-1.0.0/src/nexuscalc.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+nexuscalc = nexuscalc:calculate
+

nexuscalc-1.0.0/src/nexuscalc.egg-info/top_level.txt

@@ -0,0 +1 @@
+nexuscalc