#################################  One Time TOKEN  ##################################################

from django.contrib.auth.tokens import PasswordResetTokenGenerator

from six import text_type

class OneTimeToken(PasswordResetTokenGenerator):

    def __make_hash_value(self, user, timestamp):

        return (text_type(user.is_active)+text_type(user.pk)+text_type(timestamp))

one_time_token = OneTimeToken()

#one_time_token_generator.make_token(user)

#one_time_token_generator.check_token(user, token)

####################################################################################################

################################## TOTP TOKEN ####################################################

import pyotp

import qrcode

from qrcode.image.svg import SvgImage

from io import BytesIO

from django.http import JsonResponse

class TOTP_Token:

    def __get_qrcode_svg(self,uri):

        stream = BytesIO()

        img = qrcode.make(uri, image_factory = SvgImage)

        img.save(stream)

        return stream.getvalue().decode()

    def create_totp_token(self,user):

        key = user.profile.otp_key

        #create token

        totp = pyotp.totp.TOTP(key)

        #create uri

        totp_uri = pyotp.totp.TOTP(key).provisioning_uri(user.username,issuer_name="Souk Baalbeck")

        svg = __get_qrcode_svg(totp_uri)

        return svg

    def verify_totp_token(self,user, token):

        user_key = user.profile.otp_key

        #create token

        totp = pyotp.totp.TOTP(user_key)

        #verify if token and user match

        if token == totp.now():

            return True

        else:

            return False

totp_token = TOTP_Token()

#######################################################################################################

You can call this decorator by using @benchmark like below:

import cProfile, pstats, io 

def benchmark(fnc):

    def inner(*args, **kwargs):

        pr = cProfile.Profile()

        pr.enable()

        original_fnc = fnc(*args,**kwargs)

        pr.disable()

        s = io.StringIO()

        ps = pstats.Stats(pr, stream=s).sort_stats('cumulative')

        ps.print_stats()

        print('benchmark result = ', s.getvalue())

        return original_fnc

    return i

Simple example on how to use it:

@benchmark

def testfunction(number):

    numbers = []

    for i in range(number):

        numbers.append(i)

    return numbers

testfunction(1000000)

Threading

Here u will find 2 ways: (Class or functionnal):

import threading

class sendActivationUrlThread(threading.Thread):

    def __init__(self, email):

        self.email = email

        threading.Thread.__init__(self)

    def run(self):

        self.email.send(fail_silently=False)

def sendEmail(email):

    email.send(fail_silently=False)

def sendActivationUrl(request, user):

    uidb64 = urlsafe_base64_encode(force_bytes(user.pk))

    domain=get_current_site(request).domain

    the_aes_token = aes_token.AESencrypt({'user_id':user.pk})

    link = reverse('authentification:activate', kwargs={

        'token':one_time_token.make_token(user),

        'aestoken':the_aes_token

        })

    activate_url = 'http://'+domain+link

    email_subject = "Validate Your Email"

    email_body = "Hi " + user.username + ". Please use this link to verify your account\n"+activate_url

    email = EmailMessage(

        email_subject,

        email_body,

        'noreply@bookmarker.com',

        [user.email]

    )

    #sendActivationUrlThread(email).start()

    my_thread = threading.Thread(target=sendEmail, args=[email,])

    my_thread.start()

Multiprocessing

import multiprocessing

#args ne prend pas request

p = multiprocessing.Process(target = blabla , args = [])

p.start()

p.join()