[WIP] Tikhon Puntus

final_task/calculator/checker/__init__.py

@@ -0,0 +1,7 @@
+from .checker import (
+    check_spaces,
+    check_brackets,
+    check_constant,
+    check_function,
+    check_expression,
+)

final_task/calculator/checker/checker.py

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+"""
+The module is designed to test the mathematical expression for correctness.
+
+Example:
+        check_spaces(' 1+ 3 / 2')
+        >>> '1+3/2'
+
+        check_brackets('2*(3+5)')
+        >>> '2*(3+5)'
+
+        lib = {
+            'e': 2.718281828459045,
+            'sum': sum
+        }
+        check_function('sum(100, 50)', lib)
+        >>> 'sum(100, 50)'
+"""
+
+import re
+from ..library import Library
+from ..operators import (
+    LEFT_BRACKET,
+    RIGHT_BRACKET,
+)
+from ..regexp import (
+    REGEXP_INCORECT_EXPRETION,
+    REGEXP_CONSTANT,
+    REGEXP_DIGIT,
+    REGEXP_FUNCTION,
+)
+
+
+def check_spaces(expr: str) -> str:
+    """
+    Checks if an expression has the wrong elements.
+
+    Args:
+        expr (str): String mathematical expression.
+
+    Returns:
+        str: cleared expression from spaces.
+
+    Raises:
+        ValueError: If `expr` is not correct`.
+    """
+    matches = re.findall(REGEXP_INCORECT_EXPRETION, expr)
+    if matches:
+        raise ValueError('expression is not correct')
+
+    return expr.replace(' ', '')
+
+
+def check_brackets(expr: str):
+    """
+    Checks if all brackets have a pair.
+
+    Args:
+        expr (str): String mathematical expression.
+
+    Raises:
+        ValueError: If `expr` is not correct`.
+    """
+    stack = []
+    for symbol in expr:
+        if symbol == LEFT_BRACKET:
+            stack.append(symbol)
+        elif symbol == RIGHT_BRACKET and (not stack or stack.pop() != LEFT_BRACKET):
+            raise ValueError('brackets are not balanced')
+
+    if stack:
+        raise ValueError('brackets are not balanced')
+
+
+def check_constant(expr: str, library: Library):
+    """
+    Checks if all constants in the expression are available.
+
+    Args:
+        expr (str): String mathematical expression.
+        library (Library): dictionary of functions and constant.
+
+    Raises:
+        ValueError: If `expr` is not correct`.
+    """
+    matches = re.finditer(REGEXP_CONSTANT, expr)
+    for match in matches:
+        name = match.group('name')
+
+        if name[-1] == LEFT_BRACKET or re.match(REGEXP_DIGIT, name):
+            continue
+
+        if name[0].isdigit():
+            raise ValueError(f'constant {name} can not start with digit')
+
+        if name not in library or callable(library[name]):
+            raise ValueError(f'there is no such constant {name}')
+
+
+def check_function(expr: str, library: Library):
+    """
+    Checks if all functions in the expression are available.
+
+    Args:
+        expr (str): String mathematical expression.
+        library (Library): dictionary of functions and constant.
+
+    Raises:
+        ValueError: If `expr` is not correct`.
+    """
+    matches = re.finditer(REGEXP_FUNCTION, expr)
+    for match in matches:
+        name = match.group('name')
+        pattern = match.group('pattern')
+
+        if name[0].isdigit():
+            raise ValueError(f'function {pattern} can not start with digit')
+
+        if name not in library or not callable(library[name]):
+            raise ValueError(f'there is no such function {pattern}')
+
+
+def check_expression(expr: str, library: Library) -> str:
+    """
+    Checks the expression for correctness.
+
+    Args:
+        expr (str): String mathematical expression.
+        library (Library): dictionary of functions and constant.
+
+    Returns:
+        str: cleared expression.
+
+    Raises:
+        ValueError: If `expr` is not correct`.
+    """
+    expr = check_spaces(expr)
+    check_brackets(expr)
+    check_constant(expr, library)
+    check_function(expr, library)
+
+    return expr

final_task/calculator/checker/test_checker.py

@@ -0,0 +1,115 @@
+import unittest
+from ..library import Library
+from .checker import (
+    check_brackets,
+    check_constant,
+    check_expression,
+    check_function,
+    check_spaces,
+)
+
+
+class TestCheckFunction(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.lib = Library('math')
+
+    def test_check_spaces(self):
+        with self.subTest("Throws error if spaces is not correct"):
+            self.assertRaises(ValueError, lambda: check_spaces(''))
+            self.assertRaises(ValueError, lambda: check_spaces('------'))
+            self.assertRaises(ValueError, lambda: check_spaces('-'))
+            self.assertRaises(ValueError, lambda: check_spaces('+'))
+            self.assertRaises(ValueError, lambda: check_spaces('1-'))
+            self.assertRaises(ValueError, lambda: check_spaces('1 + 1 2 3 4 5 6 '))
+            self.assertRaises(ValueError, lambda: check_spaces('* *'))
+            self.assertRaises(ValueError, lambda: check_spaces('/ /'))
+            self.assertRaises(ValueError, lambda: check_spaces('/ *'))
+            self.assertRaises(ValueError, lambda: check_spaces('+ *'))
+            self.assertRaises(ValueError, lambda: check_spaces('1 2'))
+            self.assertRaises(ValueError, lambda: check_spaces('= ='))
+            self.assertRaises(ValueError, lambda: check_spaces('! ='))
+            self.assertRaises(ValueError, lambda: check_spaces('<-+!'))
+            self.assertRaises(ValueError, lambda: check_spaces('==7'))
+            self.assertRaises(ValueError, lambda: check_spaces('1 + 2(3 * 4))'))
+            self.assertRaises(ValueError, lambda: check_spaces('1 = = 2'))
+            self.assertRaises(ValueError, lambda: check_spaces('1<>2'))
+            self.assertRaises(ValueError, lambda: check_spaces('1><2'))
+
+        with self.subTest("removes spaces and returns new expretion"):
+            self.assertEqual(check_spaces('1   +   2'), '1+2')
+            self.assertEqual(check_spaces('1-2'), '1-2')
+            self.assertEqual(check_spaces('1 * - 2'), '1*-2')
+            self.assertEqual(check_spaces('1 == 2'), '1==2')
+            self.assertEqual(check_spaces('1 <= 2'), '1<=2')
+            self.assertEqual(check_spaces('1 - sin  (1,    2,  3) + - 2'), '1-sin(1,2,3)+-2')
+            self.assertEqual(check_spaces('sin(pi/2)'), 'sin(pi/2)')
+            self.assertTrue(check_spaces('sin(e^log(e^e^sin(23.0),45.0)+cos(3.0+log10(e^-e)))'))
+            self.assertTrue(check_spaces('time()-e-(1+1)/60+1-1*1//10000%1000^2==1==1<=3>=5<1>1'))
+
+            val = ('sin(-cos(-sin(3.0)-cos(-sin(-3.0*5.0)-sin(cos(log10(43.0))))'
+                   '+cos(sin(sin(34.0-2.0^2.0))))--cos(1.0)--cos(0.0)^3.0)')
+            self.assertTrue(check_spaces(val))
+
+    def test_check_brackets(self):
+        with self.subTest("Throws error if brackets are not unpaired"):
+            self.assertRaises(ValueError, lambda: check_brackets('('))
+            self.assertRaises(ValueError, lambda: check_brackets(')'))
+            self.assertRaises(ValueError, lambda: check_brackets('())('))
+            self.assertRaises(ValueError, lambda: check_brackets('(()))'))
+            self.assertRaises(ValueError, lambda: check_brackets(')()('))
+
+        with self.subTest("returns nothing if expretion is good"):
+            self.assertIsNone(check_brackets(''))
+            self.assertIsNone(check_brackets('()'))
+            self.assertIsNone(check_brackets('((()))()'))
+            self.assertIsNone(check_brackets('()()()()'))
+            self.assertIsNone(check_brackets('(()(()())())'))
+
+    def test_check_constant(self):
+        with self.subTest("Throws error if environment does not have constant"):
+            self.assertRaises(ValueError, lambda: check_constant('constant', self.lib))
+            self.assertRaises(ValueError, lambda: check_constant('constant + 5', self.lib))
+            self.assertRaises(ValueError, lambda: check_constant('sin(1) + constant + 7', self.lib))
+
+        with self.subTest("Throws error if constant name starts with digit"):
+            self.assertRaises(ValueError, lambda: check_constant('10constant', self.lib))
+            self.assertRaises(ValueError, lambda: check_constant('10constant + 5', self.lib))
+            self.assertRaises(ValueError, lambda: check_constant('sin(1) + 10constant + 7', self.lib))
+
+        with self.subTest("returns nothing if expretion is good"):
+            self.assertIsNone(check_constant('', self.lib))
+            self.assertIsNone(check_constant('e', self.lib))
+            self.assertIsNone(check_constant('sin(21)', self.lib))
+            self.assertIsNone(check_constant('sin(21) + e', self.lib))
+            self.assertIsNone(check_constant('2.4178516392292583e+24 + 5', self.lib))
+
+    def test_check_function(self):
+        with self.subTest("Throws error if environment does not have function"):
+            self.assertRaises(ValueError, lambda: check_function('multiply()', self.lib))
+            self.assertRaises(ValueError, lambda: check_function('multiply(5,7)', self.lib))
+            self.assertRaises(ValueError, lambda: check_function('multiply() + 7', self.lib))
+
+        with self.subTest("Throws error if function name starts with digit"):
+            self.assertRaises(ValueError, lambda: check_function('10log()', self.lib))
+            self.assertRaises(ValueError, lambda: check_function('10log(1)', self.lib))
+            self.assertRaises(ValueError, lambda: check_function('10log(5,7)', self.lib))
+            self.assertRaises(ValueError, lambda: check_function('10log() + 7', self.lib))
+
+        with self.subTest("returns nothing if expretion is good"):
+            self.assertIsNone(check_function('', self.lib))
+            self.assertIsNone(check_function('e', self.lib))
+            self.assertIsNone(check_function('sin(21)', self.lib))
+            self.assertIsNone(check_function('sin(21) + e', self.lib))
+            self.assertIsNone(check_function('2.4178516392292583e+24 + 5', self.lib))
+
+    def test_check_expression(self):
+        with self.subTest("returns expression without spaces"):
+            self.assertEqual(check_expression('1   +   2', self.lib), '1+2')
+            self.assertEqual(check_expression('1-2', self.lib), '1-2')
+            self.assertEqual(check_expression('1 * - 2', self.lib), '1*-2')
+            self.assertEqual(check_expression('1 - sin  (1,    2,  3) + - 2', self.lib), '1-sin(1,2,3)+-2')
+
+
+if __name__ == '__main__':
+    unittest.main()

final_task/calculator/converter/__init__.py

@@ -0,0 +1 @@
+from .converter import convert_answer

final_task/calculator/converter/converter.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+"""
+The module is designed to convert the expression to the desired type.
+
+Example:
+        convert_answer('-1', False)
+        >>> '-1'
+
+        convert_answer('-1', False)
+        >>> '0'
+
+        convert_answer('-1', True)
+        >>> 'True'
+
+        convert_answer('0', True)
+        >>> 'False'
+"""
+
+from ..regexp import has_non_zero_fraction_part
+
+
+def convert_answer(expr: str, has_compare: bool) -> str:
+    """
+    Converts the resulting string to the desired type.
+
+    Args:
+        expr (str): String representation of a number.
+        has_compare (bool): whether the expression contains boolean logic
+    """
+    num = float(expr)
+    match = has_non_zero_fraction_part(expr)
+    num = num if match else int(num)
+
+    result = bool(num) if has_compare else num
+
+    return str(result)

final_task/calculator/converter/test_converter.py

@@ -0,0 +1,15 @@
+import unittest
+from .converter import convert_answer
+
+
+class TestConverterFunction(unittest.TestCase):
+    def test_convert_answer(self):
+        with self.subTest("returns correct answer"):
+            self.assertEqual(convert_answer('-1', False), '-1')
+            self.assertEqual(convert_answer('0', False), '0')
+            self.assertEqual(convert_answer('-1', True), 'True')
+            self.assertEqual(convert_answer('0', True), 'False')
+
+
+if __name__ == '__main__':
+    unittest.main()

final_task/calculator/library/__init__.py

@@ -0,0 +1 @@
+from .library import Library

final_task/calculator/library/library.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+"""
+The module is designed for dynamic creation of module libraries.
+
+Example:
+        lib = Library('math', 'os')
+        lib.update('time', 'os')
+
+        lib['e']
+        >>> 2.718281828459045
+
+        lib['sum'](5, 10)
+        >>> 15
+"""
+
+
+class Library(dict):
+    """
+    Class is designed to work with modules.
+    It is a dictionary of functions and constants.
+    """
+    def __init__(self, *modules: list):
+        super().__init__()
+
+        self['abs'] = abs
+        self['round'] = round
+
+        self.update(*modules)
+
+    def update(self, *modules: list):
+        """Adds functions and veriables from got module names to dictionary."""
+        for module in modules:
+            super().update(__import__(module).__dict__)

final_task/calculator/library/test_library.py

@@ -0,0 +1,38 @@
+import unittest
+from .library import Library
+
+
+class TestLibraryClass(unittest.TestCase):
+    def test__init__(self):
+        with self.subTest("contains around and abs functon by default"):
+            lib = Library()
+
+            self.assertTrue('round' in lib)
+            self.assertTrue('abs' in lib)
+
+        with self.subTest("can get module names and adds their variables to your own dictionary"):
+            lib = Library('math', 'os', 'time')
+
+            self.assertTrue('path' in lib)
+            self.assertTrue('clock' in lib)
+            self.assertTrue('pi' in lib)
+
+    def test_update(self):
+        with self.subTest("get module names and adds their variables to your own dictionary"):
+            lib = Library()
+            self.assertFalse('path' in lib)
+
+            lib.update('os')
+            self.assertTrue('path' in lib)
+
+            lib.update('sys', 'time')
+            self.assertTrue('stdin' in lib)
+            self.assertTrue('clock' in lib)
+
+        with self.subTest("raises error if veriable is not found"):
+            self.assertRaises(ModuleNotFoundError, lambda: lib.update('bad_module'))
+            self.assertRaises(ModuleNotFoundError, lambda: lib.update('new_math'))
+
+
+if __name__ == '__main__':
+    unittest.main()