parse4u 1.0.0__tar.gz

parse4u-1.0.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: parse4u
+Version: 1.0.0
+Summary: converts python language into plain english
+Author-email: Fawaz Shariff <placeholder0254@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Chungywungy/BCIT-Hacakathon
+Project-URL: Documentation, https://github.com/Chungywungy/BCIT-Hacakathon
+Project-URL: Source, https://github.com/Chungywungy/BCIT-Hacakathon/tree/main/src/parse4u
+Keywords: automation,parsing,Summarizing
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# BCIT-Hacakathon

parse4u-1.0.0/README.md

@@ -0,0 +1 @@
+# BCIT-Hacakathon

parse4u-1.0.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=80.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "parse4u"
+version = "1.0.0"
+description = "converts python language into plain english"
+readme = { file = "README.md", content-type = "text/markdown" }
+license = { text = "MIT" }
+authors = [
+  { name = "Fawaz Shariff", email = "placeholder0254@gmail.com" }
+]
+requires-python = ">=3.12"
+
+dependencies = [
+
+]
+
+keywords = ["automation", "parsing", "Summarizing"]
+
+[project.urls]
+Homepage = "https://github.com/Chungywungy/BCIT-Hacakathon"
+Documentation = "https://github.com/Chungywungy/BCIT-Hacakathon"
+Source = "https://github.com/Chungywungy/BCIT-Hacakathon/tree/main/src/parse4u"
+
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+
+[project.scripts]

parse4u-1.0.0/setup.cfg

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

parse4u-1.0.0/src/parse4u/docstring_generator.py

@@ -0,0 +1,26 @@
+import parse_function_declaration
+import iterables
+
+
+def main():
+    print("Enter/Paste your content. Type \" END \" or press Ctrl-D or Ctrl-Z on windows to save it.")
+    contents = []
+    while True:
+        try:
+            line = input()
+            if line == "END":
+                break
+        except EOFError:
+            break
+        contents.append(line)
+
+
+    line1 = parse_function_declaration.parse_function_declaration(contents[0])
+    contents.pop(0)
+    result = iterables.conditionals(contents)
+
+    print(line1)
+    print(result)
+
+if __name__ == "__main__":
+    main()

parse4u-1.0.0/src/parse4u/identify_assignment.py

@@ -0,0 +1,33 @@
+import identify_operation
+
+
+def identify_assignment(split_string: str):
+    if "=" in split_string and "==" not in split_string:
+        return True
+    return None
+
+
+def print_assignment(split_string_line: str):
+    string_parts = split_string_line.split("=")
+    assignee = string_parts[0].strip()
+    string_parts.pop(0)
+    index = 0
+    assigner = ""
+    while index < len(string_parts):
+        assigner = identify_operation.identify_operations(string_parts[index].strip())
+        index += 1
+
+    return f"Sets {assignee} equal to {assigner}"
+
+
+def main():
+    my_string = "x = y"
+    if identify_assignment(my_string):
+        print_assignment(my_string)
+    my_string = "x = y + z"
+    if identify_assignment(my_string):
+        print(print_assignment(my_string))
+
+
+if __name__ == "__main__":
+    main()

parse4u-1.0.0/src/parse4u/identify_functions.py

@@ -0,0 +1,51 @@
+def replaces_function_calls(line):
+    """
+    Acts as the final call to a function which translate any builtin function to its English counterpart. The function
+    will not interfere with any of the grammatical structure of the passed string. That is, it will only replace a
+    builtin named function.
+
+    :param line:
+    :return:
+    """
+    english_translation_look_up = {
+        "int": lambda param: f"{param} as an integer",
+        "list": lambda param: f"{param} as a list",
+        "str": lambda param: f"{param} as a string",
+        "type": lambda param: f"the type of {param}",
+        "input": lambda param: f"user input provided from the prompt {param}",
+        "print": lambda param: f"prints {param} to the console",
+        "range": lambda param: f"range of {param}",
+        "len": lambda param: f"length of {param}"
+    }
+
+    new_string = line
+
+    for basic_function, eng_translation in english_translation_look_up.items():
+        remaining = new_string
+        while basic_function + "(" in remaining:
+            function_call_index = remaining.index(basic_function + "(")
+            # make sure it's not part of another word e.g. "int" inside "print"
+            if function_call_index > 0 and remaining[function_call_index - 1].isalpha():
+                break
+            # stops at the index of the first parameter passed
+            start = remaining.index(basic_function + "(") + len(basic_function) + 1
+            # starts looking for the closing  from the start index
+            end = remaining.rindex(")", start)
+            # slices the line to parse argument
+            args = remaining[start: end].strip()
+            function_call = remaining[function_call_index: end + 1]
+            new_string = new_string.replace(function_call, eng_translation(args))
+            # looks if there are any instances of other basic functions invoked in the line
+            remaining = remaining[end + 1:]
+
+    return new_string
+
+
+def main():
+    pass
+
+
+if __name__ == "__main__":
+    main()
+
+

parse4u-1.0.0/src/parse4u/identify_logical_operators.py

@@ -0,0 +1,193 @@
+"""
+This module identifies and explains logical operations and comparison operations in
+a line of a function.
+"""
+import identify_operation
+
+
+def parse_logical_operators(split_string: str, operator: str) -> list:
+    """
+    Divide a string by the operator in the string.
+
+    :param split_string: string representing a line of code
+    :param operator: is a logical or a membership operator
+    :postcondition: convert the split_string into a list
+    :postcondition: make a copy of this list
+    :postcondition: find the location of the operator
+    :postcondition: pop the elements in the copied list to form the second operand
+    :postcondition: move each popped element into a new list to form the right operand
+    :return: list containing right operands and left operands
+    """
+    parts = split_string.split()
+    logical_operator_location = parts.index(operator)
+    index = 0
+    first_term = []
+    parts_copy = parts[:]
+    while index <= logical_operator_location:
+        if parts_copy[index] == operator:
+            parts.pop(0)
+            index += 1
+        else:
+            first_term.append(parts_copy[index])
+            parts.pop(0)
+            index += 1
+    first_operand = " ".join(first_term)
+    second_operand = " ".join(parts)
+    return [first_operand, second_operand]
+
+
+def identify_comparison_operators(split_string: str):
+    """
+    Recursively identify and explain the comparison operators in an expression in a plain English( a line of code).
+
+    :param split_string: string representing a line of code
+    :precondition: split_string is a correctly formatted string
+    :postcondition: find the comparison operator and pride English description of the comparison,
+                    assignment, or arithmetic operation found in split_string
+    :postcondition: recursively processes split_string by splitting on the first
+                    comparison operator found, formatting the left side into plain
+                    English, and passing the right side back into itself until no
+                    comparison operators remain; the base case delegates to
+                    identify_assignment or identify_operations
+    :return: a plain English string describing the full expression as a string or a call to assignment
+             function if it's a simple assignment (=), or call to identify operation function to check
+             for any other operations that could be in an expression
+    """
+    if "==" in split_string:
+        result = parse_logical_operators(split_string, "==")
+        return f"{identify_comparison_operators(result[0])} is equal to {identify_comparison_operators(result[1])}"
+    elif "!=" in split_string:
+        result = parse_logical_operators(split_string, "!=")
+        return f"{identify_comparison_operators(result[0])} is not equal to {identify_comparison_operators(result[1])}"
+    elif "<=" in split_string:
+        result = parse_logical_operators(split_string, "<=")
+        return f"{identify_comparison_operators(result[0])} is less than or equal to {identify_comparison_operators(result[1])}"
+    elif ">=" in split_string:
+        result = parse_logical_operators(split_string, ">=")
+        return f"{identify_comparison_operators(result[0])} is greater than or equal to{identify_comparison_operators(result[1])}"
+    elif "<" in split_string:
+        result = parse_logical_operators(split_string, "<")
+        return f"{identify_comparison_operators(result[0])} is less than {identify_comparison_operators(result[1])}"
+    elif ">" in split_string:
+        result = parse_logical_operators(split_string, ">")
+        return f"{identify_comparison_operators(result[0])} is greater than {identify_comparison_operators(result[1])}"
+    else:
+        return identify_operation.identify_operations(split_string)
+
+
+def identify_membership_operators(split_string: str):
+    """
+    Recursively identify and explain membership operations in an expression.
+
+    Checks for operators in the order not, and, or, is, in.
+    Splits the expression on the first operator found, recursively processes
+    both sides, and combines them into a plain English description.
+    If none of these operators are present, call
+    identify_comparison_operators as the base case, which will investigate any other operations that
+    might be seen in the expression such as comparison, math operations etc.
+
+    :param split_string:  string representing a line of code
+    :precondition: correctly formatted string representing a valid Python expression
+    :postcondition: recursively splits split_string on the first membership or
+                    logical operator found, processes the left and right sides
+                    independently, and combines them into a plain English string
+    :postcondition: correctly handle partial expressions where one side may be None by
+                    returning only the non-None side with the other operator
+    :return: a plain English string describing the full expression built
+             recursively, or call to comparison operators function to check for any other
+             operations in the expressions from there
+    """
+    parts = split_string.split()
+    if "not" in parts:
+        not_index = parts.index("not")
+        result = parse_logical_operators(split_string, "not")
+        first_operand = identify_membership_operators(result[0])
+        second_operand = identify_membership_operators(result[1])
+        if parts[not_index + 1] == "in":
+            if result[0] is None:
+                return f"is not in{second_operand}"
+            elif result[1] is None:
+                return f"{first_operand}is not in"
+            else:
+                return f"{first_operand} is not{second_operand}"
+        elif parts[not_index - 1] == "is":
+            if result[0] is None:
+                return f"not {second_operand}"
+            elif result[1] is None:
+                return f"{first_operand} not"
+            else:
+                return f"{first_operand}not {second_operand}"
+        else:
+            if result[0] is None:
+                return f"is not{second_operand}"
+            elif result[1] is None:
+                return f"{first_operand} is not"
+            else:
+                return f"{first_operand} is not {second_operand}"
+    elif "and" in parts:
+        result = parse_logical_operators(split_string, "and")
+        first_operand = identify_membership_operators(result[0])
+        second_operand = identify_membership_operators(result[1])
+        if result[0] is None:
+            return f"and {second_operand}"
+        elif result[1] is None:
+            return f"{first_operand} and"
+        else:
+            return f"{first_operand} and {second_operand}"
+    elif "or" in parts:
+        result = parse_logical_operators(split_string, "or")
+        first_operand = identify_membership_operators(result[0])
+        second_operand = identify_membership_operators(result[1])
+        if result[0] is None:
+            return f"or {second_operand}"
+        elif result[1] is None:
+            return f"{first_operand} or"
+        else:
+            return f"{first_operand} or {second_operand}"
+    elif "is" in parts:
+        result = parse_logical_operators(split_string, "is")
+        first_operand = identify_membership_operators(result[0])
+        second_operand = identify_membership_operators(result[1])
+        if result[0] is None:
+            return f"is {second_operand}"
+        elif result[1] is None:
+            return f"{first_operand} is"
+        else:
+            return f"{first_operand} is {second_operand}"
+    elif "in" in parts:
+        result = parse_logical_operators(split_string, "in")
+        first_operand = identify_membership_operators(result[0])
+        second_operand = identify_membership_operators(result[1])
+        if result[0] is None:
+            return f"in {second_operand}"
+        elif result[1] is None:
+            return f"{first_operand} in"
+        else:
+            return f"{first_operand} in {second_operand}"
+    else:
+        return identify_comparison_operators(split_string)
+
+
+def main():
+    """
+    Drive the program.
+    """
+    print(identify_membership_operators("x not in y"))
+    print(identify_membership_operators("x not y"))
+    print(identify_membership_operators("x in y"))
+    print(identify_membership_operators("x in y and x is not z or is x and not p"))
+    print(identify_comparison_operators("x == y"))
+    print(identify_comparison_operators("x != y"))
+    print(identify_comparison_operators("x <= y"))
+    print(identify_comparison_operators("x >= y"))
+    print(identify_comparison_operators("x = y"))
+    print(identify_comparison_operators("x + y"))
+    print(identify_comparison_operators("x == y + z * 3"))
+    print(identify_comparison_operators("x > y"))
+    print(identify_comparison_operators("x < y"))
+    print(identify_comparison_operators("x = y"))
+    print(identify_comparison_operators("guess_conversion > 5 or guess_conversion < 1"))
+
+
+if __name__ == "__main__":
+    main()

parse4u-1.0.0/src/parse4u/identify_operation.py

@@ -0,0 +1,91 @@
+# assume that the function is split and each line of code is
+# stored in a string inside a list, we loop
+# so list[index] refers to each line in the string
+# precondition : there is a white space around operators -saba
+
+# i think += and -= should be in assignment instead of operators, im not going to move them this instant but
+# this should be considered for making everything mesh in the future when we're refactoring this -ollie
+
+def return_operations(split_string: str, operator: str) -> list:
+    """
+    Extracts the two operands surrounding a given operator in a tokenized expression string.
+
+    :param split_string: a whitespace-separated expression string
+    :param operator: the operator token to locate
+    :precondition: there is a white space around the operators
+    :postcondition: find the index of the operator, split the strings in 2 parts,
+                    first operand (left of the operator) and second operand (right of the operator)
+    :return: a two-element list, the first operand (immediately left
+             of the operator) and the second operand (all remaining tokens joined).
+    """
+    parts = split_string.split(operator)
+    first_operand = parts[0].strip()
+    second_operand = parts[1].strip()
+
+    return [first_operand, second_operand]
+
+def identify_operations(split_string: str) -> str:
+    """
+    Recursively translates a Python arithmetic expression string into plain English.
+
+    :param split_string: a whitespace-separated arithmetic expression
+    :precondition: split_string is a whitespace-separated expression string containing
+                  at most one operator per recursive level. Compound operators ( += or -= etc.)
+                  must be checked before their substrings (e.g. +) to avoid mismatches.
+    :postcondition: whenever there is an operation in the line, split it calling the return_operation
+                   function, to get the right hand side and left hand side of the operation
+    :postcondition: repeat the process until there's no other arithmetic operation in the line
+    :postcondition: if split_string contains no recognized operator, it is returned unchanged
+                    as the base case of the recursion
+    :return: a plain-English translation of the arithmetic operation in an expression in string
+    """
+    if "+=" in split_string:
+        result = return_operations(split_string, "+=")
+
+        return f"Increases {result[0]} by {identify_operations(result[1])}"
+    elif "-=" in split_string:
+        result = return_operations(split_string, "-=")
+
+        return f"Decrease {result[0]} by {identify_operations(result[1])}"
+    elif "**=" in split_string:
+        # we should do this first otherwise we're not getting into this block
+        result = return_operations(split_string, "**=")
+
+        return f"Set {result[0]} to itself raised to the power of {identify_operations(result[1])}."
+    elif "*=" in split_string:
+        # *= and * are translated the same
+        result = return_operations(split_string, "*=")
+
+        return f"Multiply {result[0]} by {identify_operations(result[1])}"
+    elif "/=" in split_string:
+        result = return_operations(split_string, "/=")
+
+        return f"Divide {result[0]} by {identify_operations(result[1])}"
+    elif "%=" in split_string:
+        result = return_operations(split_string, "%=")
+
+        return f"Set {result[0]} to the remainder when divided by {identify_operations(result[1])}"
+    elif "=" in split_string:
+        result = return_operations(split_string, "=")
+
+        return f"sets {result[0]} equal to {identify_operations(result[1])}"
+    elif "**" in split_string:
+        return split_string.replace("**", "^")
+    else:
+        return split_string
+
+
+def main():
+    my_string = "x += y"
+    print(identify_operations(my_string))
+    my_second_string = "x + y"
+    print(identify_operations(my_second_string))
+    # i minorly refactored this function for this exact case. i feel like this reads a heck of a lot better than
+    # "increases x by x added to y" which is what the recursive case would give us. i will look more into what
+    # sort of edge cases this approach could produce though and we'll come up with a final decision tmrw
+    my_third_string = "x += (x + (c ** y)) * 2"
+    print(identify_operations(my_third_string))
+
+
+if __name__ == "__main__":
+    main()

parse4u-1.0.0/src/parse4u/iterables.py

@@ -0,0 +1,109 @@
+from src.parse4u.identify_logical_operators import *
+from src.parse4u.identify_functions import *
+from try_except import *
+
+def while_loop(split_string: str) -> str | None:
+    if "while" in split_string:
+        storage = split_string.split(":")[0].split("while")[1].strip()
+
+
+        return (f'While {replaces_function_calls(identify_comparison_operators(storage))} is true, it repeatedly '
+                f' {continuation(split_string)}{breaker(split_string)}{passer(split_string)}')
+
+
+def for_loop(split_string: str) -> str | None:
+    if "for" in split_string:
+        idx = split_string.find("for")
+        if split_string[idx + len("for")].isalpha(): return None
+        split_string = split_string.split()
+        return (f"Iterates through each {split_string[1]} in the {replaces_function_calls(split_string[3].replace(":", ""))} using a for loop. "
+                f"{continuation(split_string)}{breaker(split_string)}{passer(split_string)} ")
+
+
+def continuation(split_string):
+    if "continue" in split_string:
+        return f"the loop then goes to the top and begins again "
+    return ""
+
+def breaker(split_string):
+    if "break" in split_string:
+        return f"it then exits the loop "
+    else:
+        return ""
+
+def passer(split_string):
+    if "pass" in split_string:
+        return "calls pass"
+    else:
+        return ""
+
+
+def conditionals(split_string: list):
+    lambdamentality = {
+        "if": lambda statement: f"checks if {replaces_function_calls(identify_comparison_operators(statement))} then ",
+        "elif": lambda statement: f"otherwise it checks {replaces_function_calls(identify_comparison_operators(statement))} then ",
+        "else": lambda statement: f"if none of these conditions are true it "
+    }
+
+    container = []
+
+    for line in split_string:
+        non_applicable = False
+        for cond in {"elif", "else", "if"}:
+            if cond in line:
+                argument = line[len(cond):].strip().split(":")[0]
+                container.append(f"{lambdamentality[cond](argument)}" )
+                non_applicable = True
+                break
+
+            while_output = while_loop(line)
+            if while_output:
+                container.append(while_output)
+                non_applicable = True
+                break
+
+            for_output = for_loop(line)
+            if for_output:
+                container.append(for_output)
+                non_applicable = True
+                break
+
+            continuation_output = continuation(line)
+            if continuation_output:
+                container.append(continuation_output+"\n")
+                non_applicable = True
+                break
+
+            breaker_output = breaker(line)
+            if breaker_output:
+                container.append(breaker_output+"\n")
+                non_applicable = True
+                break
+
+            passer_output = passer(line)
+            if passer_output:
+                container.append(passer_output+"\n")
+                non_applicable = True
+                break
+
+            try_except_output = try_and_except(line)
+            if try_except_output:
+                container.append(try_except_output+"\n")
+                non_applicable = True
+                break
+
+        if not non_applicable:
+            value = replaces_function_calls(identify_comparison_operators(line))
+            container.append(value.strip()+"\n")
+
+
+    return "".join(container)
+
+
+def main():
+    code_block_conditionals = ["if 1 > int(2):", "do_anything()", "elif 1 < range(2):", "please_work()", "else:", "1 + 2"]
+    sample = ["while number > 1: pass"]
+    return conditionals(sample)
+
+if __name__ == "__main__":
+    print(main())

parse4u-1.0.0/src/parse4u/parse_function_declaration.py

@@ -0,0 +1,170 @@
+"""
+Parses functions declarations and annotations.
+
+Assumption: 
+Only parses annotations when available
+
+def function_name(x: int, y: float) -> int:
+def function_name(x, y):
+def function_name() -> str:
+def function_name():
+"""
+
+
+def get_return_type(function_string: str) -> str:
+    """
+    Get the function's return type.
+    :param function_string: a string of text representing the line declaring a function in the python language
+    :precondition: function_string must be a syntactically correct string for declaring a function
+    :postcondition: parse the data type that the function will return, if available
+    :return: a string that represents the function's returns data type
+    """
+    if "def" and "->" in function_string:
+        return_type = function_string.split("->")
+        return_type = return_type[1].replace(":", "").strip()
+        # this gets the return type of the function
+    else:
+        return_type = ""  # return type is None when the function_string does not include the return annotation
+    # print("return type:", return_type)
+    return return_type
+
+
+def get_function_name(function_string: str) -> str:
+    """
+    Get the function's name.
+    :param function_string: a string of text representing the line declaring a function in the python language
+    :precondition: function_string must be a syntactically correct string for declaring a function
+    :postcondition: correctly parse the function name
+    :return: the function name as a string
+    """
+    # removes def from the string
+    if "def" in function_string:
+        function_string = function_string.replace("def", "")
+
+    split_function_string = function_string.split("(")
+    function_name = split_function_string[0].strip()
+    # splits string at ( to get the function name
+    # print("function name:", function_name)
+
+    return function_name
+
+
+def get_parameters(function_string: str) -> str:
+    """
+    Get parameters in function.
+    :param function_string: a string of text representing the line declaring a function in the python language
+    :precondition: function_string must be a syntactically correct string for declaring a function
+    :postcondition: translate the text for the parameters
+    :return: a description of the parameters as the string
+    """
+    left_split_function_string = function_string.split("(")
+
+    right_split_function_string = left_split_function_string[1].split(")")
+    parameters = right_split_function_string[0]
+    # split at the '(' and ')' to get everything in between the parentheses
+
+    if parameters and ":" in parameters:  # runs if there are parameters with annotations
+        parameters_list = parameters.split(",")  # returns a list of variables and function annotations
+        # parse parameters; create dictionary to hold each parameter and its type
+
+        variable_type_dict = {}
+        for item in parameters_list:
+            stripped_item = item.strip()
+
+            if ":" in stripped_item:
+                parameter_annotation = stripped_item.split(":")
+                variable = parameter_annotation[0].strip()  # this gets the variable that will become the key in dict
+                variable_type = parameter_annotation[1].strip()  # this is the variable type that will be the value pair
+                variable_type_dict[variable] = variable_type
+
+        # iterating through the variables to create a list to hold parameter descriptions
+        parameter_description = []
+        for key, value in variable_type_dict.items():
+            parameter_description.append(f"{key} as {value}")
+        # creates list to hold parameter descriptions i.e. ['x as int, y as float']
+
+        if len(parameters_list) >= 3:
+            parameter_text = "{}, and {} for parameters".format(", ".join(parameter_description[:-1]),
+                                                                parameter_description[-1])
+        elif len(parameters_list) == 2:
+            parameter_text = "{} for parameters".format(" and ".join(parameter_description), )
+        else:
+            parameter_text = "{} for a parameter".format(", ".join(parameter_description), )
+
+    elif parameters and ":" not in parameters:  # runs case where parameters exist, but no annotations are written
+        parameters_list = parameters.split(",")
+        stripped_parameters_list = []
+
+        for item in parameters_list:
+            stripped_item = item.strip()
+            stripped_parameters_list.append(stripped_item)
+
+        if len(parameters_list) >= 3:
+            parameter_text = "{}, and {} for parameters".format(", ".join(stripped_parameters_list[:-1]),
+                                                                stripped_parameters_list[-1])
+        elif len(parameters_list) == 2:
+            parameter_text = "{} for parameters".format(" and ".join(stripped_parameters_list))
+        else:
+            parameter_text = "{} for a parameter".format(", ".join(stripped_parameters_list), )
+
+    else:  # runs in the case there are no parameters
+        parameter_text = "no parameters"
+
+    return parameter_text
+
+
+def parse_function_declaration(function_string: str) -> str:
+    """
+    Put together full text string to give brief description of the function declaration.
+    :param function_string: a string of text representing the line declaring a function in the python language
+    :precondition: function_string must be a syntactically correct string for declaring a function
+    :postcondition: correctly describe the function declaration
+    :return: a string that describes the function declaration
+    """
+    return_type = get_return_type(function_string)
+    function_name = get_function_name(function_string)
+    parameter_text = get_parameters(function_string)
+
+    if return_type:  # runs if there is a return type
+        function_declaration_string = (f"{function_name} is declared as a function. It takes {parameter_text} and "
+                                       f"returns {return_type}.")
+    else:  #runs if there return type is None
+        function_declaration_string = f"{function_name} is declared as a function. It takes {parameter_text}."
+
+    return function_declaration_string
+
+
+def main():
+    """
+    Drive the function.
+    """
+    # with 3 parameters and annotations
+    print(parse_function_declaration("def function_name(x: int, y: float, z: str) -> int:"))
+
+    #with 2 parameters and annotations
+    print(parse_function_declaration("def function_name(x: int, y: float) -> int:"))
+
+    # with 1 parameter and annotations
+    print(parse_function_declaration("def function_name(x: int) -> int:"))
+
+    # with 3 parameters without annotations
+    print(parse_function_declaration("def function_name(x, y, z) -> int:"))
+
+    # with 2 parameters without annotations
+    print(parse_function_declaration("def function_name(x, y) -> int:"))
+
+    # with 1 parameter without annotations
+    print(parse_function_declaration("def function_name(x) -> int:"))
+
+    # with parameters without annotations, without return annotation
+    print(parse_function_declaration("def function_name(x, y)"))
+
+    #without parameters
+    print(parse_function_declaration("def another_function() -> int:"))
+
+    #without parameters and return annotation
+    print(parse_function_declaration("def wow_another_one():"))
+
+
+if __name__ == "__main__":
+    main()

parse4u-1.0.0/src/parse4u/try_except.py

@@ -0,0 +1,27 @@
+def try_and_except(split_string):
+    lines = split_string.split()
+
+    for term in lines:
+        if "try:" == term:
+            return "The function tries performing the following actions:"
+        elif "raise" in term:
+            error = lines[1].split("(")
+            error_message = error[1] + " " + lines[2].replace(")","")
+            return f"The function will raise an {error[0]} with message, {error_message}."
+        elif "except" in term:
+            lines[1] = lines[1].replace(":", "")
+            return f"If the function fails to perform these actions a {lines[1]} will occur, so the function:"
+        elif "finally:" == term:
+            return "Finally, the function will:"
+        else:
+            return None
+
+
+def main():
+    print(try_and_except("try:"))
+    print(try_and_except("except ValueError:"))
+    print(try_and_except("raise ValueError(\"Useful message\")"))
+    print(try_and_except("finally:"))
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: parse4u
+Version: 1.0.0
+Summary: converts python language into plain english
+Author-email: Fawaz Shariff <placeholder0254@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Chungywungy/BCIT-Hacakathon
+Project-URL: Documentation, https://github.com/Chungywungy/BCIT-Hacakathon
+Project-URL: Source, https://github.com/Chungywungy/BCIT-Hacakathon/tree/main/src/parse4u
+Keywords: automation,parsing,Summarizing
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# BCIT-Hacakathon

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

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/parse4u/__init__.py
+src/parse4u/docstring_generator.py
+src/parse4u/identify_assignment.py
+src/parse4u/identify_functions.py
+src/parse4u/identify_logical_operators.py
+src/parse4u/identify_operation.py
+src/parse4u/iterables.py
+src/parse4u/parse_function_declaration.py
+src/parse4u/try_except.py
+src/parse4u.egg-info/PKG-INFO
+src/parse4u.egg-info/SOURCES.txt
+src/parse4u.egg-info/dependency_links.txt
+src/parse4u.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+parse4u