Merge pull request #12 from mayureshagashe2105/main

techdocs/utils/functools.py

@@ -43,6 +43,8 @@ def request_inference(config, code_block, max_retries=1):
         return request_inference(config, code_block, max_retries=max_retries-1)
     
 
-    
+def update_file(file_path, docstr_code):
+    with open(file_path, "w",errors='ignore') as file:
+        file.write(docstr_code)
 
     

techdocs/utils/parse.py

@@ -1,6 +1,7 @@
 import ast
 import os
 import requests
+import threading
 
 from utils.functools import *
 
@@ -36,5 +37,6 @@ def extract_functions_from_directory(config):
                 parsed = ast.parse(content)
                 extract_outermost_function(parsed, config)
                 docstr_code = ast.unparse(parsed)
-                with open(file_path, "w",errors='ignore') as file:
-                    file.write(docstr_code)
+
+                write_thread = threading.Thread(target=update_file, args=(file_path, docstr_code))
+                write_thread.start()

testing/DBQueries.py

@@ -0,0 +1,94 @@
+import pydantic
+from bson.objectid import ObjectId
+pydantic.json.ENCODERS_BY_TYPE[ObjectId] = str
+from typing import Union, Tuple, List
+from backend.utils import DBConnection
+from backend.core.Exceptions import *
+
+class DBQueries:
+
+    @classmethod
+    def insert_to_database(cls, table_name: str, data: Union[Tuple, List[Tuple]], cols: List[str]=None):
+        """
+    This method is used to insert data into a specified table in the database.
+
+    Args:
+    table_name (str): The name of the table where the data will be inserted.
+    data (Union[Tuple, List[Tuple]]): The data to be inserted into the table. It can be either a tuple or a list of tuples.
+    cols (List[str], optional): A list of column names in the table. If not provided, the method will assume that all columns are required. Defaults to None.
+
+    Raises:
+    TypeError: If the data is not a tuple or a list of tuples.
+    """
+        con = DBConnection.get_client()
+        cursor = con.cursor()
+        QUERY = f"INSERT INTO {{table_name}} ({','.join(cols)}) VALUES ".format(table_name=table_name)
+        print(data)
+        if isinstance(data, list):
+            QUERY += '(' + ','.join(['%s' for _ in range(len(data[0]))]) + ')'
+            cursor.executemany(QUERY, data)
+        else:
+            QUERY += '(' + ','.join(['%s' for _ in range(len(data))]) + ')'
+            cursor.execute(QUERY, data)
+        con.commit()
+
+    @classmethod
+    def fetch_data_from_database(cls, table_name: str, cols_to_fetch: Union[str, List[str]], where_clause: str=None):
+        """
+    This method is a class method that fetches data from a specified table in the database based on the specified
+    column names and an optional WHERE clause.
+
+    Args:
+    - table_name (str): The name of the table from which to fetch data.
+    - cols_to_fetch (Union[str, List[str]]): The column(s) to fetch from the table. If a single string, it should
+      be a comma-separated list of column names.
+    - where_clause (str, optional): An optional WHERE clause to filter the fetched data. Defaults to None.
+
+    Returns:
+    - List[tuple]: A list of tuples, where each tuple represents a row of data fetched from the database.
+
+    Raises:
+    - None
+    """
+        con = DBConnection.get_client()
+        cursor = con.cursor()
+        if isinstance(cols_to_fetch, str):
+            cols_to_fetch = [cols_to_fetch]
+        cols_to_fetch = ', '.join(cols_to_fetch)
+        QUERY = 'SELECT {cols} FROM {table_name}'.format(cols=cols_to_fetch, table_name=table_name)
+        if where_clause:
+            QUERY = QUERY + ' WHERE ' + where_clause
+        cursor.execute(QUERY)
+        return cursor.fetchall()
+
+    @classmethod
+    def update_data_in_database(cls, table_name: str, cols_to_update: Union[str, List[str]], where_clause: str=None, new_values: Union[str, List[str]]=None):
+        """
+    This function is used to update data in a specific table in the database.
+
+    Args:
+        table_name (str): The name of the table in which the data needs to be updated.
+        cols_to_update (Union[str, List[str]]): The column(s) that need to be updated. If a single string, it should end with '=%s'. If a list, elements should be separated by '=%s, '.join(cols_to_update).
+        where_clause (str, optional): The WHERE clause to specify the condition for updating the data. Defaults to None.
+        new_values (Union[str, List[str]], optional): The new values that need to be updated in the specified columns. If a single string, it should be a list of new values. Defaults to None.
+
+    Returns:
+        bool: Returns True if the data is successfully updated in the database.
+
+    Raises:
+        None
+    """
+        con = DBConnection.get_client()
+        cursor = con.cursor()
+        if isinstance(cols_to_update, str):
+            cols_to_update = cols_to_update + '=%s'
+        else:
+            cols_to_update = '=%s, '.join(cols_to_update)
+        if isinstance(new_values, str):
+            new_values = [new_values]
+        QUERY = 'UPDATE {table_name} SET {cols}'.format(table_name=table_name, cols=cols_to_update)
+        if where_clause:
+            QUERY = QUERY + ' WHERE ' + where_clause
+        cursor.execute(QUERY, new_values)
+        con.commit()
+        return True

testing/test.py

@@ -1,18 +1,105 @@
 def add(a, b):
+    """
+    This function adds two numbers.
+
+    Arguments:
+    a (int): The first number to be added.
+    b (int): The second number to be added.
+
+    Returns:
+    int: Returns the sum of the two numbers.
+
+    Raises:
+    TypeError: If the input is not an integer.
+    """
+    '\n    This function adds two numbers.\n\n    Arguments:\n    a (int): The first number to be added.\n    b (int): The second number to be added.\n\n    Returns:\n    int: Returns the sum of the two numbers.\n\n    Raises:\n    TypeError: If the input is not an integer.\n    '
     return a + b
 
 def multiply(a, b):
+    """
+    This function multiplies two given numbers.
+
+    Arguments:
+    a (int or float): The first number to be multiplied.
+    b (int or float): The second number to be multiplied.
+
+    Returns:
+    int or float: The product of the two numbers.
+
+    Raises:
+    TypeError: If the input types are not numbers (int or float).
+
+    """
+    '\n    This function multiplies two given numbers.\n\n    Arguments:\n    a (int or float): The first number to be multiplied.\n    b (int or float): The second number to be multiplied.\n\n    Returns:\n    int or float: The product of the two numbers.\n\n    Raises:\n    TypeError: If the input types are not numbers (int or float).\n\n    '
     return a * b
 
 def subtract(a, b):
+    """
+    This function subtracts the second number from the first number.
+
+    Args:
+    a (int): The first number to be subtracted.
+    b (int): The second number to be subtracted from the first number.
+
+    Returns:
+    int: Returns the result of the subtraction.
+
+    Raises:
+    TypeError: If the input arguments are not integers.
+    """
+    '\n    This function subtracts the second number from the first number.\n\n    Args:\n    a (int): The first number to be subtracted.\n    b (int): The second number to be subtracted from the first number.\n\n    Returns:\n    int: Returns the result of the subtraction.\n\n    Raises:\n    TypeError: If the input arguments are not integers.\n    '
     return a - b
 
 def divide(a, b):
+    """
+    This function divides the first argument by the second argument.
+
+    Arguments:
+    a (float): First argument to be divided.
+    b (float): Second argument by which the first argument is to be divided.
+
+    Returns:
+    float: Returns the result of the division of the first argument by the second argument.
+
+    Raises:
+    ValueError: If the second argument is zero, it raises a ValueError with the message 'Cannot divide by zero'.
+    """
+    "\n    This function divides the first argument by the second argument.\n\n    Arguments:\n    a -- First argument to be divided. It should be a float.\n    b -- Second argument by which the first argument is to be divided. It should be a float.\n\n    Returns:\n    float -- Returns the result of the division of the first argument by the second argument.\n\n    Raises:\n    ValueError -- If the second argument is zero, it raises a ValueError with the message 'Cannot divide by zero'.\n    "
     if b == 0:
         raise ValueError('Cannot divide by zero')
     return a / b
 
 def func(*args, **kwargs):
+    """
+    This function is a decorator that wraps another function and returns a new function that acts as a wrapper.
+
+    Arguments:
+    func (function): The function to be wrapped.
+    * args (tuple): Positional arguments to be passed to the wrapped function.
+    * kwargs (dict): Keyword arguments to be passed to the wrapped function.
+
+    Returns:
+    A new function that acts as a wrapper for the original function.
+
+    Raises:
+    None
+"""
+    '\nThis function is a decorator that wraps another function and returns a new function that acts as a wrapper.\n\nArgs:\n    func (function): The function to be wrapped.\n\nKwargs:\n    Any additional keyword arguments are passed to the wrapped function.\n\nReturns:\n    A new function that acts as a wrapper for the original function.\n\nRaises:\n    None\n'
+
     def wrapper(*args, **kwargs):
+        """
+    This function performs a specific operation on a list of integers.
+
+    Arguments:
+    n (int): The size of the list.
+    k (int): The value to be searched in the list.
+
+    Returns:
+    A list of integers representing the result of the operation.
+
+    Raises:
+    ValueError: If the input arguments are not integers.
+    """
+        "\n    This function is a wrapper that calls another function (specified by 'func') with the given arguments.\n\n    Arguments:\n    * args (tuple): Positional arguments to be passed to 'func'.\n    * kwargs (dict): Keyword arguments to be passed to 'func'.\n\n    Returns:\n    Whatever 'func' returns.\n\n    Raises:\n    Whatever exceptions 'func' raises.\n    "
         return func(*args, **kwargs)
     return wrapper