Převod do číselné soustavy

.gitignore

@@ -0,0 +1,3 @@
+.idea/
+__pycache__
+.coverage

__init__.py

@@ -0,0 +1,6 @@
+"""Initialization script for number system conversion app."""
+from .app import App
+
+if __name__ == "__main__":
+    application = App()
+    application.run()

app.py

@@ -0,0 +1,87 @@
+"""Base App class to run this application."""
+
+from .number_system import BinarySystem, OctalSystem, HexSystem
+
+
+class App:
+    """Application class to run this app."""
+
+    def run(self):
+        """Init function to run whole app."""
+        App.print_help()
+
+        input_number = self.parse_input_number()
+
+        if input_number is None:
+            print("Program end requested. Exiting...")
+            return
+
+        target_number_system = self.parse_target_number_system()
+
+        print(target_number_system.convert_decimal(input_number))
+
+    def parse_input_number(self):
+        """Handle user number input."""
+        number = input("Please pass unsigned integer: ")
+
+        try:
+            if self.is_ending(number):
+                return None
+
+            number = int(number)
+
+            if number < 0:
+                raise ValueError
+
+        except ValueError:
+            print("Not a valid unsigned integer! Please try once again.")
+            return self.parse_input_number()
+
+        return number
+
+    def parse_target_number_system(self):
+        """Handle user target system input."""
+        target_system = input("Please choose target number system: ")
+
+        try:
+            if self.is_ending(target_system):
+                return None
+
+            target_system = int(target_system)
+
+            if target_system not in [1, 2, 3]:
+                raise ValueError
+        except ValueError:
+            print("Not a valid target system! Please try once again.")
+            return self.parse_target_number_system()
+
+        if target_system == 1:
+            return BinarySystem()
+
+        if target_system == 2:
+            return OctalSystem()
+
+        return HexSystem()
+
+    @staticmethod
+    def is_ending(char):
+        """Check ending string."""
+        if char == "#":
+            return True
+
+        return False
+
+    @staticmethod
+    def print_help():
+        """Print help text."""
+        print(
+            "You can convert numbers from decimal system to " +
+            "binary, octal or hex systems.")
+        print("At first you need to pass number" +
+              " in decimal system.")
+        print("Then you need to choose target number " +
+              "system by selecting number.")
+        print("1. Binary")
+        print("2. Octal")
+        print("3. Hex")
+        print("At final enjoy your result.")

number_system.py

@@ -0,0 +1,36 @@
+"""Module with number system representations."""
+
+from abc import ABC, abstractmethod
+
+
+class NumberSystem(ABC):
+    """Abstract class to number systems."""
+
+    @abstractmethod
+    def convert_decimal(self, number):
+        """Abstract method to convert decimal number."""
+        pass
+
+
+class BinarySystem(NumberSystem):
+    """Class representing binary number system."""
+
+    def convert_decimal(self, number):
+        """Convert decimal number into binary one."""
+        return bin(number)
+
+
+class OctalSystem(NumberSystem):
+    """Class representing octal number system."""
+
+    def convert_decimal(self, number):
+        """Convert decimal number into octal one."""
+        return oct(number)
+
+
+class HexSystem(NumberSystem):
+    """Class representing hexadecimal number system."""
+
+    def convert_decimal(self, number):
+        """Convert decimal number into hex one."""
+        return hex(number)

test_app.py

@@ -0,0 +1,51 @@
+"""Test module for app class."""
+
+import builtins
+from .app import App
+from .number_system import BinarySystem, OctalSystem, HexSystem
+
+
+class TestApp:
+    """App class tests."""
+
+    def test_parse_input_number_ending(self):
+        """Test if ending input returns proper value."""
+        app = App()
+        builtins.input = lambda x: '#'
+
+        assert app.parse_input_number() is None
+
+    def test_parse_input_valid_input(self):
+        """Test if valid input returns proper value."""
+        app = App()
+        builtins.input = lambda x: '64'
+
+        assert app.parse_input_number() == 64
+
+    def test_parse_target_number_system_ending(self):
+        """Test if ending input returns proper value."""
+        app = App()
+        builtins.input = lambda x: '#'
+
+        assert app.parse_target_number_system() is None
+
+    def test_parse_target_number_system_return_binary_system(self):
+        """Test if proper input returns proper number system."""
+        app = App()
+        builtins.input = lambda x: '1'
+
+        assert isinstance(app.parse_target_number_system(), BinarySystem)
+
+    def test_parse_target_number_system_return_octal_system(self):
+        """Test if proper input returns proper number system."""
+        app = App()
+        builtins.input = lambda x: '2'
+
+        assert isinstance(app.parse_target_number_system(), OctalSystem)
+
+    def test_parse_target_number_system_return_hex_system(self):
+        """Test if proper input returns proper number system."""
+        app = App()
+        builtins.input = lambda x: '3'
+
+        assert isinstance(app.parse_target_number_system(), HexSystem)

test_number_system.py

@@ -0,0 +1,25 @@
+"""Test for number system classes."""
+
+from .number_system import BinarySystem, OctalSystem, HexSystem
+
+
+class TestNumberSystem:
+    """Number system testing class."""
+
+    def test_convert_decimal_to_binary(self):
+        """Test binary system conversion method."""
+        binary_number_system = BinarySystem()
+
+        assert binary_number_system.convert_decimal(64) == '0b1000000'
+
+    def test_convert_decimal_to_octal(self):
+        """Test octal system conversion method."""
+        octal_number_system = OctalSystem()
+
+        assert octal_number_system.convert_decimal(64) == '0o100'
+
+    def test_convert_decimal_to_hex(self):
+        """Test hex system conversion method."""
+        hex_number_system = HexSystem()
+
+        assert hex_number_system.convert_decimal(64) == '0x40'