testgenie-py 0.2.8__py3-none-any.whl → 0.2.9__py3-none-any.whl

testgen/controller/docker_controller.py

@@ -1,4 +1,3 @@
-import importlib
 import os
 import sys
 from argparse import Namespace
@@ -6,7 +5,10 @@ import docker
 from docker import DockerClient, client
 from docker import errors
 from docker.models.containers import Container
-import importlib.resources
+import importlib.resources as pkg_resources
+import tempfile
+import shutil
+
 from testgen.service.logging_service import get_logger
 from testgen.service.service import Service
 
@@ -134,7 +136,6 @@ class DockerController:
         print(f"Docker args: {docker_args}")
         print(f"Project root: {project_root}")
         
-        
         return docker_client.containers.run(
                 image=image_name,
                 command=["testgenie"] + docker_args,
@@ -192,23 +193,23 @@ class DockerController:
             return False
 
     def get_dockerfile_path(self) -> str:
-        print("Get dockerfile path")
+        # First, try local development path
         local_dockerfile = os.path.join(os.path.dirname(__file__), "docker", "Dockerfile")
-        print(f"Checking local path: {local_dockerfile}")
         if os.path.exists(local_dockerfile):
+            self.debug(f"Found local Dockerfile at: {local_dockerfile}")
             return local_dockerfile
 
         # If not found locally, try inside installed package
         try:
-            print("With importlib.resources")
-            with importlib.resources.path('testgen.docker', 'Dockerfile') as dockerfile_path:
-                print(f"Checking package path: {dockerfile_path}")
-                if dockerfile_path.exists():
-                    return str(dockerfile_path)
+            dockerfile_resource = pkg_resources.files('testgen').joinpath('docker/Dockerfile')
+            if dockerfile_resource.is_file():
+                self.debug(f"Found package-installed Dockerfile at: {dockerfile_resource}")
+                return str(dockerfile_resource)
         except Exception as e:
             print(f"Error locating Dockerfile in package resources: {e}")
 
-        raise FileNotFoundError("Dockerfile not found in local project or package.")
+        print("Dockerfile not found in local project or package.")
+        sys.exit(1)
 
     @staticmethod
     def is_inside_docker() -> bool:

testgen/service/service.py

@@ -457,8 +457,8 @@ class Service:
         loader = unittest.TestLoader()
         self.logger.debug(f"Discovering tests in: {os.path.dirname(file_path_to_use)} with pattern: {os.path.basename(test_file)}")
         test_module = os.path.relpath(test_file,
-                                      start=os.getcwd())
-        test_module = test_module.replace("/", ".").replace("\\", ".").rstrip(".py")
+                                      start=os.getcwd())  # Get relative path from the current working directory
+        test_module = test_module.replace("/", ".").replace("\\", ".").rstrip(".py")  # Convert to module name
         if test_module.startswith("."):
             test_module = test_module[1:]  # Remove leading dot if present
         self.logger.debug(f"Test module: {test_module}")

{testgenie_py-0.2.8.dist-info → testgenie_py-0.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: testgenie-py
-Version: 0.2.8
+Version: 0.2.9
 Summary: Automated unit test generation tool for Python.
 Author: cjseitz
 Author-email: charlesjseitz@gmail.com

{testgenie_py-0.2.8.dist-info → testgenie_py-0.2.9.dist-info}/RECORD

@@ -1,4 +1,3 @@
-testgen/.coverage,sha256=NYSARpg1eBFSMEuoMcK98U5uK0xbwwS3s2V5TPGI7fw,69632
 testgen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 testgen/analyzer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 testgen/analyzer/ast_analyzer.py,sha256=fUtrJQsgnKeSKqKaXSO_ZsY_uQr2aPeyTQP9ToyFEg4,6886
@@ -11,17 +10,9 @@ testgen/analyzer/random_feedback_analyzer.py,sha256=hDcNIWE4BFtsoyXHWyxcC1qeq7y9
 testgen/analyzer/reinforcement_analyzer.py,sha256=U6W7g-xDFS_P0aqxjPRnaXjGp2gOC9TMdfWaetFV7eE,3568
 testgen/analyzer/test_case_analyzer.py,sha256=0qLcRKOrQ4Uyh1ZMecVTkY9bWjNnx7OridigNyjfUk4,1620
 testgen/analyzer/test_case_analyzer_context.py,sha256=7umDPHBjoTaCRvZOdNynpnWsr14Gy0E2hpMBPK8mz3Q,2128
-testgen/code_to_test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-testgen/code_to_test/boolean.py,sha256=RM2byJDKFTx1FFrxnPG_uZWb24OcOH20Uh-D1Z-yPcE,3373
-testgen/code_to_test/calculator.py,sha256=j7lw21BYg_vxaQVCrjOlhQOpObjSe5gu9xzthmdGphk,830
-testgen/code_to_test/code_to_fuzz.py,sha256=cwgRpUdXjTlrUHSHMtA2TAj8Y-ddAn6CaUdXPM4MRmo,4826
-testgen/code_to_test/code_to_fuzz_lite.py,sha256=EjS4GB5klnJrvZIDDpS9iIt0iZETVJI0ez9DmihMiYc,10429
-testgen/code_to_test/decisions.py,sha256=ZiW-EF1yTOWeQVZ7Xh0oIPHK2NSNPUzVxCY0E2GbYvQ,1376
-testgen/code_to_test/math_utils.py,sha256=FqPQz5-e1oklzGyTVYNO8JMKDg5ob8z05VOlpKfKvvw,853
-testgen/code_to_test/sample_code_bin.py,sha256=kMvV_-oFeAkxUmDx41Pw0iTTmMG1pvX31TezXPWMOkE,4225
 testgen/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 testgen/controller/cli_controller.py,sha256=A3TsJQT20UI2TlBqC7SyI8TG0n1vP_Itd1K8TRoD3ps,8735
-testgen/controller/docker_controller.py,sha256=azqOn217s49M9kKy61jm43-D6J4q8pNOcw0vswBbO7U,8316
+testgen/controller/docker_controller.py,sha256=M6Q_tiAGX8j4lH1NLUFMTCreKXmoKTEpgo60z-KWVRg,8343
 testgen/docker/Dockerfile,sha256=6mutzP0ZkVueuvMLCOy2bsyGxWjLHU-cq7RFkuC8r5Y,781
 testgen/generated_boolean.py,sha256=i5at_BZ7YHtveTMYB0JKMFIkBe7cwhCeF5AViLhNoWA,1146
 testgen/generated_samplecodebin.py,sha256=pf_aYtcfpjZzgiZ_FiBOxfug_ii3dRX0jnozBgQm7Xw,17030
@@ -52,15 +43,11 @@ testgen/service/analysis_service.py,sha256=uPoPJFLh4Imf5y_Zd8pX9zxRijr-D0K0WV22Y
 testgen/service/cfg_service.py,sha256=Czr91D5AHVq38yPKyhZDjM5jMObGPvY0yPE-PxNVBYM,2326
 testgen/service/generator_service.py,sha256=3JCWRlg5UKNhKRG9VXIycDFmuYKsRTzEmhmtlxroWAc,8088
 testgen/service/logging_service.py,sha256=tCv9LHL1gUScQQp34_iYoUxfCFzLRtFG_DXRsJ73SjA,3189
-testgen/service/service.py,sha256=7GLCC5acVcrnUqWEByGizdO8eIKMOUhTIUGymbDCe18,20793
+testgen/service/service.py,sha256=j_tbvale6rIHfBFtJKWT1CYzSRT5tN6muU2RxaQRRRA,20875
 testgen/sqlite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 testgen/sqlite/db.py,sha256=RUt88ndT4CQRo9aZzLGXPHRK1iw0LyDEGnoWlOLzKGM,2390
 testgen/sqlite/db_service.py,sha256=F2ug_FBrYOQtJwM2cMkvQrTS54_VhWGDAHXndnTi-c8,9768
-testgen/testgen.db,sha256=JjksVfefobXyMot1xwhA3bXtJ2y8jpIXu_Plz13IrlY,53248
-testgen/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-testgen/tests/test_boolean.py,sha256=eS0raGCrPtVZbZqyU7InW3Pzy5HAgiGIYt6UmPUxkMk,1924
-testgen/tests/test_code_to_fuzz_lite.py,sha256=B66_FNIULxkMIL48oSGx1fsxCo3tF4cp7VyhlrZAfZI,8574
-testgen/tests/test_generated_boolean.py,sha256=QOmfu8sgWanrpY-OKY8u09l0q2Q7m4oJST6Llg64ka0,2493
+testgen/testgen.db,sha256=EQVBRtHL8KcjzXni8Hrg2XwSyXWWt6GXY82NGHklfgE,45056
 testgen/tree/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 testgen/tree/node.py,sha256=ONJtbACShN4yNj1X-UslFRgLyBP6mrbg7qZr3c6dWyA,165
 testgen/tree/tree_utils.py,sha256=gT7jucky6_GWVOlDI6jpv6RMeWCkntGOHIYLvHxD85k,2122
@@ -76,34 +63,7 @@ testgen/util/z3_utils/branch_condition.py,sha256=N9FNR-iJmxIC62NpDQNVZ1OP14rXXqY
 testgen/util/z3_utils/constraint_extractor.py,sha256=RXJLpmk6dAvHZ27839VXKXNtdy9St1F-17-pSEFu4bM,1285
 testgen/util/z3_utils/variable_finder.py,sha256=dUh3F9_L_BDMz1ybiGss09LLcM_egbitgj0FT5Nh9u4,245
 testgen/util/z3_utils/z3_test_case.py,sha256=yF4oJOrXMLzOwDUqXdoeg83MOTl3pvc_lYaZcS01CuQ,4983
-testgen/visualize/boolean_bin_and_coverage.png,sha256=W91WI9xvu8-uxUcS6wAekWtVMV8G_JEq-_rCqt8vSas,38291
-testgen/visualize/boolean_bin_and_coverage_v1.png,sha256=W91WI9xvu8-uxUcS6wAekWtVMV8G_JEq-_rCqt8vSas,38291
-testgen/visualize/boolean_bin_and_coverage_v2.png,sha256=W91WI9xvu8-uxUcS6wAekWtVMV8G_JEq-_rCqt8vSas,38291
-testgen/visualize/boolean_bin_and_coverage_v3.png,sha256=W91WI9xvu8-uxUcS6wAekWtVMV8G_JEq-_rCqt8vSas,38291
-testgen/visualize/boolean_bin_and_coverage_v4.png,sha256=W91WI9xvu8-uxUcS6wAekWtVMV8G_JEq-_rCqt8vSas,38291
-testgen/visualize/boolean_bin_and_coverage_v5.png,sha256=W91WI9xvu8-uxUcS6wAekWtVMV8G_JEq-_rCqt8vSas,38291
-testgen/visualize/boolean_bin_and_coverage_v6.png,sha256=W91WI9xvu8-uxUcS6wAekWtVMV8G_JEq-_rCqt8vSas,38291
-testgen/visualize/boolean_bin_and_coverage_v7.png,sha256=W91WI9xvu8-uxUcS6wAekWtVMV8G_JEq-_rCqt8vSas,38291
-testgen/visualize/boolean_bin_and_coverage_v8.png,sha256=W91WI9xvu8-uxUcS6wAekWtVMV8G_JEq-_rCqt8vSas,38291
-testgen/visualize/boolean_bin_xor_coverage.png,sha256=nmzDr4Qc2Hd3pdxrgAVWdXe7fks9c4UAyvp2PsTYPgM,45945
-testgen/visualize/boolean_bin_xor_coverage_v1.png,sha256=nmzDr4Qc2Hd3pdxrgAVWdXe7fks9c4UAyvp2PsTYPgM,45945
-testgen/visualize/boolean_bin_xor_coverage_v2.png,sha256=nmzDr4Qc2Hd3pdxrgAVWdXe7fks9c4UAyvp2PsTYPgM,45945
-testgen/visualize/boolean_bin_xor_coverage_v3.png,sha256=hJ6CRK1iBpbD5EQ0Zhv4iD3QIq6wHJeAFb4VpkPDWDI,44454
-testgen/visualize/boolean_bin_xor_coverage_v4.png,sha256=hJ6CRK1iBpbD5EQ0Zhv4iD3QIq6wHJeAFb4VpkPDWDI,44454
-testgen/visualize/boolean_bin_xor_coverage_v5.png,sha256=hJ6CRK1iBpbD5EQ0Zhv4iD3QIq6wHJeAFb4VpkPDWDI,44454
-testgen/visualize/boolean_bin_xor_coverage_v6.png,sha256=hJ6CRK1iBpbD5EQ0Zhv4iD3QIq6wHJeAFb4VpkPDWDI,44454
-testgen/visualize/boolean_bin_xor_coverage_v7.png,sha256=hJ6CRK1iBpbD5EQ0Zhv4iD3QIq6wHJeAFb4VpkPDWDI,44454
-testgen/visualize/boolean_bin_xor_coverage_v8.png,sha256=hJ6CRK1iBpbD5EQ0Zhv4iD3QIq6wHJeAFb4VpkPDWDI,44454
-testgen/visualize/boolean_status_flags_coverage.png,sha256=KmfPse_7gt71JdfkKFY7Pcja90yNmSEvh7LQK1I0sMg,69661
-testgen/visualize/boolean_status_flags_coverage_v1.png,sha256=KmfPse_7gt71JdfkKFY7Pcja90yNmSEvh7LQK1I0sMg,69661
-testgen/visualize/boolean_status_flags_coverage_v2.png,sha256=KmfPse_7gt71JdfkKFY7Pcja90yNmSEvh7LQK1I0sMg,69661
-testgen/visualize/boolean_status_flags_coverage_v3.png,sha256=SCMgwC8Oes_0J7P2oJasx0psC_7pnjJTvpioZilmrUE,71519
-testgen/visualize/boolean_status_flags_coverage_v4.png,sha256=sI5T39fTA0ou11myDZCw8kvJmRmWkMUxXwzmPdz_GJ0,71538
-testgen/visualize/boolean_status_flags_coverage_v5.png,sha256=SCMgwC8Oes_0J7P2oJasx0psC_7pnjJTvpioZilmrUE,71519
-testgen/visualize/boolean_status_flags_coverage_v6.png,sha256=KmfPse_7gt71JdfkKFY7Pcja90yNmSEvh7LQK1I0sMg,69661
-testgen/visualize/boolean_status_flags_coverage_v7.png,sha256=KmfPse_7gt71JdfkKFY7Pcja90yNmSEvh7LQK1I0sMg,69661
-testgen/visualize/boolean_status_flags_coverage_v8.png,sha256=KmfPse_7gt71JdfkKFY7Pcja90yNmSEvh7LQK1I0sMg,69661
-testgenie_py-0.2.8.dist-info/METADATA,sha256=614Q86G6T2Ftu0SiXLT7tuunxj51g5ndtLjN0kz4f1Q,4350
-testgenie_py-0.2.8.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-testgenie_py-0.2.8.dist-info/entry_points.txt,sha256=OUN4GqB4zHlHWwWGjwIPbur4E_ZqQgkeeqaCLhzRZgg,47
-testgenie_py-0.2.8.dist-info/RECORD,,
+testgenie_py-0.2.9.dist-info/METADATA,sha256=x8FM6FoDZMDEwwrMGBT3JN_FXGA2edB4sNl2SQkWjcs,4350
+testgenie_py-0.2.9.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+testgenie_py-0.2.9.dist-info/entry_points.txt,sha256=OUN4GqB4zHlHWwWGjwIPbur4E_ZqQgkeeqaCLhzRZgg,47
+testgenie_py-0.2.9.dist-info/RECORD,,

testgen/code_to_test/boolean.py

@@ -1,146 +0,0 @@
-from typing import List
-
-
-def bin_and(a: bool, b: bool) ->bool:
-    """
-    >>> bin_and(True, False)
-    False
-
-    >>> bin_and(False, True)
-    False
-
-    >>> bin_and(False, False)
-    False
-
-    >>> bin_and(True, True)
-    True
-    """
-    if a == True:
-        if b == True:
-            return True
-        else:
-            return False
-    else:
-        return False
-
-
-def bin_xor(a: bool, b: bool) ->bool:
-    """
-    >>> bin_xor(True, True)
-    False
-
-    >>> bin_xor(True, False)
-    True
-
-    >>> bin_xor(False, False)
-    False
-
-    >>> bin_xor(False, True)
-    True
-    """
-    if a == True:
-        if b == True:
-            return False
-        else:
-            return True
-    elif b == True:
-        return True
-    else:
-        return False
-
-
-def status_flags(active: bool, verified: bool, admin: bool) ->str:
-    """
-    >>> status_flags(False, False, False)
-    'inactive'
-
-    >>> status_flags(False, False, True)
-    'admin-unverified'
-
-    >>> status_flags(True, True, False)
-    'user-verified'
-
-    >>> status_flags(True, True, True)
-    'admin-verified'
-
-    >>> status_flags(True, False, False)
-    'user-unverified'
-
-    >>> status_flags(False, True, True)
-    'admin-verified'
-
-    >>> status_flags(False, True, False)
-    'inactive'
-
-    >>> status_flags(True, False, True)
-    'admin-unverified'
-    """
-    if admin:
-        if verified:
-            return 'admin-verified'
-        else:
-            return 'admin-unverified'
-    elif active:
-        if verified:
-            return 'user-verified'
-        else:
-            return 'user-unverified'
-    else:
-        return 'inactive'
-
-
-"""def half_adder(a: bool, b: bool) ->tuple:
-    sum: bool = bin_xor(a, b)
-    carry: bool = bin_and(a, b)
-    return sum, carry
-
-
-def full_adder(a: bool, b: bool, carry_in: bool) ->tuple:
-    sum1, carry = half_adder(a, b)
-    sum2, carry_out = half_adder(sum1, carry_in)
-    return sum2, carry or carry_out
-
-
-def thirty_two_bit_adder_excep(x: int, y: int) ->List[int]:
-    x_bits: List[int] = bit_converter(x)
-    y_bits: List[int] = bit_converter(y)
-    result: List[int] = [0] * 32
-    carry: bool = False
-    for i in range(32):
-        try:
-            sum_bit, carry = full_adder(x_bits[i], y_bits[i], carry)
-            result[i] = sum_bit
-        except IndexError as e:
-            print(f'Index Out of Bounds Error In ThirtyTwoBitAdder: {e}')
-            result = [1] * 32
-        if carry:
-            return OverflowError('Sum exceeds 32 bits')
-    return result
-
-
-def thirty_two_bit_adder(x: int, y: int) ->List[int]:
-    print(x.bit_length() - 1)
-    print(y.bit_length() - 1)
-    x_bits: List[int] = bit_converter(x)
-    y_bits: List[int] = bit_converter(y)
-    result: List[int] = [0] * 32
-    carry: bool = False
-    for i in range(32):
-        sum_bit, carry = full_adder(x_bits[i], y_bits[i], carry)
-        result[i] = sum_bit
-    return result
-
-def bit_converter(num: int) ->List[int]:
-    binary_str: str = bin(num)[2:]
-    print(bin(num)[2:])
-    return [int(digit) for digit in binary_str]
-
-def thirty_two_bit_adder_excep(x: int, y: int) ->List[int]:
-    x_bits: List[int] = bit_converter(x)
-    y_bits: List[int] = bit_converter(y)
-    result: List[int] = [0] * 32
-    carry: bool = False
-    for i in range(32):
-        sum_bit, carry = full_adder(x_bits[i], y_bits[i], carry)
-        result[i] = sum_bit
-    return result"""

testgen/code_to_test/calculator.py

@@ -1,29 +0,0 @@
-class AdvancedCalculator:
-
-    def evaluate(self, a: int, b: int, op: str) ->(int | float | str):
-        """>>> AdvancedCalculator().evaluate(16, 56, 'abc')
-'invalid'"""
-        if op == 'add':
-            return a + b
-        elif op == 'sub':
-            return a - b
-        elif op == 'mul':
-            return a * b
-        elif op == 'div':
-            if b == 0:
-                return 'undefined'
-            return a / b
-        else:
-            return 'invalid'
-
-    def is_in_range(self, val: float) ->str:
-        """>>> AdvancedCalculator().is_in_range(0.4023417704905361)
-'fractional'"""
-        if val < 0.0:
-            return 'below zero'
-        elif 0.0 <= val < 1.0:
-            return 'fractional'
-        elif 1.0 <= val <= 100.0:
-            return 'valid'
-        else:
-            return 'out of range'

testgen/code_to_test/code_to_fuzz.py

@@ -1,234 +0,0 @@
-from typing import List
-
-
-def bin_and(a: bool, b: bool) ->bool:
-    """"
-    >>> bin_and(True, True)
-    True
-    >>> bin_and(True, False)
-    False
-    >>> bin_and(False, True)
-    False
-    >>> bin_and(False, False)
-    False
-
-    Examples:
-    >>> bin_and(True, False)
-    False"""
-    if a == True:
-        if b == True:
-            return True
-        else:
-            return False
-    else:
-        return False
-
-
-def bin_or(a: bool, b: bool) ->bool:
-    """"
->>> bin_or(True, True)
-True
->>> bin_or(True, False)
-True
->>> bin_or(False, True)
-True
->>> bin_or(False, False)
-False
-
-Examples:
->>> bin_or(False, True)
-True"""
-    return a | b
-
-
-def bin_xor(a: bool, b: bool) ->bool:
-    """>>> bin_xor(True, True)
-False
->>> bin_xor(True, False)
-True
->>> bin_xor(False, True)
-True
->>> bin_xor(False, False)
-False
-
-Examples:
->>> bin_xor(True, True)
-False"""
-    return a ^ b
-
-
-def bin_nand(a: bool, b: bool) ->bool:
-    """>>> bin_nand(True, True)
-False
->>> bin_nand(True, False)
-True
->>> bin_nand(False, True)
-True
->>> bin_nand(False, False)
-True
-
-Examples:
->>> bin_nand(True, False)
-True"""
-    return not (a and b)
-
-
-def bin_nor(a: bool, b: bool) ->bool:
-    """>>> bin_nor(True, True)
-False
->>> bin_nor(True, False)
-False
->>> bin_nor(False, True)
-False
->>> bin_nor(False, False)
-True
-
-Examples:
->>> bin_nor(False, True)
-False"""
-    return not a | b
-
-
-def mux(c1: bool, c2: bool, x0: bool, x1: bool, x2: bool, x3: bool) ->bool:
-    """"
->>> mux(1, 1, True, False, False, False)
-True
->>> mux(1, 0, False, True, False, False)
-True
->>> mux(0, 1, False, False, True, False)
-True
->>> mux(0, 0, False, False, False, True)
-True
->>> mux(0, 0, False, False, False, False)
-False
-
-Examples:
->>> mux(False, False, False, False, False, True)
-True"""
-    return (c1 and c2 and x0) | (c1 and not c2 and x1) | (not c1 and c2 and x2
-        ) | (not c1 and not c2 and x3)
-
-
-def bin_and_bad(a: bool, b: bool) ->bool:
-    """"
->>> bin_and(True, True)
-True
->>> bin_and(True, False)
-False
->>> bin_and(False, True)
-False
->>> bin_and(False, False)
-False
-
-Examples:
->>> bin_and_bad(False, True)
-True"""
-    if a == True and b == True:
-        return a and b
-    return a or b
-
-
-def bin_or_bad(a: bool, b: bool) ->bool:
-    """"
->>> bin_or(True, True)
-True
->>> bin_or(True, False)
-True
->>> bin_or(False, True)
-True
->>> bin_or(False, False)
-False
-
-Examples:
->>> bin_or_bad(True, True)
-False"""
-    return not a | b
-
-
-def bit_converter_excep(num: int) ->List[int]:
-    """>>> bit_converter_excep(30)
-[1, 1, 1, 1, 0]"""
-    bs = bin(num)
-    binary_str = bs[2:]
-    try:
-        return [int(digit) for digit in binary_str]
-    except Exception as e:
-        print(binary_str)
-        print(bs)
-        print(f'Invalid Literal Exception in Bit Converter: {e}')
-        return
-
-
-def bit_converter(num: int) ->List[int]:
-    """
-    >>> bit_converter(25)
-    [1, 1, 0, 0, 1]
-    """
-    binary_str: str = bin(num)[2:]
-    print(bin(num)[2:])
-    return [int(digit) for digit in binary_str]
-
-
-def half_adder(a: bool, b: bool) ->tuple:
-    """>>> half_adder(True, True)
-(False, True)"""
-    sum: bool = bin_xor(a, b)
-    carry: bool = bin_and(a, b)
-    return sum, carry
-
-
-def full_adder(a: bool, b: bool, carry_in: bool) ->tuple:
-    """>>> full_adder(True, False, False)
-(True, False)"""
-    sum1, carry = half_adder(a, b)
-    sum2, carry_out = half_adder(sum1, carry_in)
-    return sum2, carry or carry_out
-
-
-def thirty_two_bit_adder_excep(x: int, y: int) ->List[int]:
-    """>>> thirty_two_bit_adder_excep(9, 3)
-None
-
-Examples:
->>> thirty_two_bit_adder_excep(34, 1)
-None"""
-    x_bits: List[int] = bit_converter(x)
-    y_bits: List[int] = bit_converter(y)
-    result: List[int] = [0] * 32
-    carry: bool = False
-    for i in range(32):
-        try:
-            sum_bit, carry = full_adder(x_bits[i], y_bits[i], carry)
-            result[i] = sum_bit
-        except IndexError as e:
-            print(f'Index Out of Bounds Error In ThirtyTwoBitAdder: {e}')
-            result = [1] * 32
-        if carry:
-            return OverflowError('Sum exceeds 32 bits')
-    return result
-
-
-def thirty_two_bit_adder(x: int, y: int) ->List[int]:
-    """>>> thirty_two_bit_adder(8, 45)
-None"""
-    print(x.bit_length() - 1)
-    print(y.bit_length() - 1)
-    x_bits: List[int] = bit_converter(x)
-    y_bits: List[int] = bit_converter(y)
-    result: List[int] = [0] * 32
-    carry: bool = False
-    for i in range(32):
-        sum_bit, carry = full_adder(x_bits[i], y_bits[i], carry)
-        result[i] = sum_bit
-    return result
-
-
-def thirty_two_bit_adder_excep(x: int, y: int) ->List[int]:
-    x_bits: List[int] = bit_converter(x)
-    y_bits: List[int] = bit_converter(y)
-    result: List[int] = [0] * 32
-    carry: bool = False
-    for i in range(32):
-        sum_bit, carry = full_adder(x_bits[i], y_bits[i], carry)
-        result[i] = sum_bit
-    return result