Add proper profiling methods.

🐞 What bugs you? We currently do not have a proper methord for profiling of src code. It makes it difficult for newcomers to find the slow methods.

🎯 Goal

1. This feature will help in finding slow methods. This can be used for solving #98 .
2. Can be used to find slow functions for refinement of codebase.

💡 Possible solutions Use of cProfile in a creative way.

• Comment below about what you’ve started working on.
• Add, commit, push your changes
• Submit a pull request and add this in comments - Addresses #<put issue number here>
• Ask for a review in comments section of pull request
• Celebrate your contribution to this project 🎉

[YJDoc2]

It would be along the lines of :

# file defining the decorator
import time
profile_data = dict()

def profile(fn):
     profile_data[fn.__name__] = list()
     if env_is_test:
          def wrapped(*args,**kwargs):
               start = time.time()
               ret = fn(args,kwargs)
               end = time.time()
               profile_data[fn.__name__].append(end-start)
               return ret
          return wrapped
     else :  # env is production
          return fn

def get_profile_data():
    # This will average each of the list and return the dict containing function name to average time dict
     .....

# in some other file, the function that is to be timed
@profile
def function_to_be_profiled():
     .....

One of the issues in this would be that time.time() returns system time, so if the python process is not scheduled for a long time , then the time reported by profile would be large, even though actual time taken by the function is small

This can be used as :

1. Decorate all functions and keep them that way. as the decorators are evaluated at before actually running the code, there will not be any overhead at run time in production, as the function returned by the decorator is same
2. Use the decorator as a tool in development to check the run-time, and remove after testing

[YJDoc2]

Hello, Would it be a good idea to make a decorator which will time the functions in test mode and return same function in production mode, so that we can identify slow functions?