sidchilling

package main

// Below is a function `sum()` that takes a number, runs a loop to add, and returns the result.
// In the main function, we call `sum()` once with a small number (e.g. 1000) and once
// with a large number (e.g. 1000000000) and prints the result. After that, the main()
// prints the string "All Done!"

// Your job is to convert the main() so that we call sum() concurrently, but wait for all the invocations
// to sum() to complete before printing "All Done".

sidchilling

# This script tests the VFS

from splinter import Browser

def main(browser):
    browser.visit(url = 'https://deals.shopsocially.com/flashsales/nikitaisawesome?cmp_id=516cfc502bba0163b6000002&offer_ref=nikitaisawesome_email')

    # Press the unlock link
    try:
  try:

sidchilling

from decorator import decorator

def my_decorator_wrapper(func, first_name, last_name):
    print 'You passed me the args: %s, %s' %(first_name, last_name)
    return func(first_name, last_name)

my_decorator_wrapper = decorator(my_decorator_wrapper)

@my_decorator_wrapper
def decorated_function(first_name, last_name):

sidchilling

# To show how we can pass arguments to decorators. We will use the decorator maker pattern
# that we saw in the previous example

def decorator_maker_with_args(decorator_arg1, decorator_arg2):

    print 'I make decorators. And I accept arguments: %s, %s' %(decorator_arg1, 
	    decorator_arg2)

    def my_decorator(func):
	# This is the decorator. The ability to pass arguments here is because of closure

sidchilling

# This script will show how a decorator maker works. This is required for understanding how
# we can pass arguments to the decorators

def decorator_maker():
    print 'I make decorators. I get executed only once when you make or create a decorator'

    def my_decorator(func):
	print 'I am a decorator. I get executed only one when you decorate a function'

	def wrapper():

sidchilling

# To make a generic decorator use *args and **kwargs

def a_decorator_passing_arbitrary_arguments(function_to_decorate):
    # The wrapper accepts any arguments
    def a_wrapper_accepting_arbitrary_arguments(*args, **kwargs):
	print 'Do I have args?'
	print args
	print kwargs
	function_to_decorate(*args, **kwargs)
    return a_wrapper_accepting_arbitrary_arguments

sidchilling

# Decorated methods is same as decorating functions. Just take 'self' into consideration

def method_friendly_decorator(method_to_decorate):
    def wrapper(self, lie):
	lie = lie + 3
	return method_to_decorate(self, lie)
    return wrapper

class Hermione(object):

sidchilling

# Passing arguments to the decorated function

# It's not magic, you just have to let the "wrapper" pass the argument

def a_decorator_passing_arguments(function_to_decorate):
    def a_wrapper_accepting_arguments(arg1, arg2):
	print 'I got args! Look: %s, %s' %(arg1, arg2)
	function_to_decorate(arg1, arg2)
    return a_wrapper_accepting_arguments

sidchilling

# More than one decorator on a function

# A decorator to make text bold
def make_bold(func):
    def wrapper_1():
	return '<b>%s</b>' %(func())
    return wrapper_1

# A decorator to make text italic
def make_italic(func):

sidchilling

# Shows how to manually define and use a decorator

# A decorator is a function which expects another function as a parameter
def my_shiny_new_decorator(a_function_to_decorate):

    # Inside, the decorator defines a function on the fly: "the wrapper".
    # This function is going to be wrapped around the original function so it can execute
    # code before and after the original function
    def the_wrapper_around_the_original_function():