import A

from A import *

from A import THINGS_YOU_WANT_TO_IMPORT_IN_A

import folder.A

from folder.A import *

from folder.A import THINGS_YOU_WANT_TO_IMPORT_IN_A

def uppercase(func):
    def wrapper():
        original_result = func()
        modified_result = original_result.upper()
        return modified_result
    return wrapper

@uppercase
def hello():
    """Return a string."""
    return 'hello world'


print(hello()) #HELLO WORLD

import time
def my_timer(func):
     def _timer(*args, **kwargs):
          start = time.time()
          result = func(*args, **kwargs)
          end = time.time()
          print(f"Execution time: {end - start}")
          return result
     return _timer

@my_timer
def delayed_mean(sample):
     time.sleep(1)
     return sum(sample) / len(sample)

"""     
how to Call 

@my_timer
def delayed_mean(sample):
     .....
or
delayed_mean = my_timer(delayed_mean)
"""

def trace(func):
    def wrapper(*args, **kwargs):
        print(f'TRACE: calling {func.__name__}() '
        f'with {args}, {kwargs}')
        original_result = func(*args, **kwargs)
        print(f'TRACE: {func.__name__}() '
            f'returned {original_result!r}')
        return original_result
    return wrapper
    
@trace
def say(name, line):
    return f'{name}: {line}'
    
>>> say('Jane', 'Hello, World')
'TRACE: calling say() with ("Jane", "Hello, World"), {}'
'TRACE: say() returned "Jane: Hello, World"'
'Jane: Hello, World'

#### * used for list & tuple
#### ** used for dictionaries

>>> {1, 2, 3} & {1, 4}
{1}
>>> {1, 2, 3} | {1, 4}
{1, 2, 3, 4}
>>> {1, 2, 3} - {1, 4}
{2, 3}
>>> {1, 2, 3} ^ {1, 4}
{2, 3, 4}

dictionary_1 | dictionary_2 #### merge two dictionary

from typing import Any

def get_ci(d: dict, key: str) -> Any:
    for k, v in d.items():
        if key.lower() == k.lower():
            return v

def concatenate(*items, delim: str):
    return delim.join(items)
 
#### example
>>> concatenate("John", "Doe", delim=" ")
'John Doe'
>>> concatenate("Ronald", "Reuel", "Tolkien", delim=" ")
'Ronald Reuel Tolkien'
>>> concatenate("Jay", delim=" ")
'Jay'
>>> concatenate(delim=" ")
''

#### simple class
class Point:
 def __init__(self, x, y):
     self.x = x
     self.y = y
 
 
 #### Every time an attribute is prefixed by __ (two underscores) within a class body
 #### it is renamed by the interpreter on the fly (private variable)
class MyClass:
 def __init__(self):
     self.__secret_value = 1

#### Example
import random

class InitOnAccess:
 def __init__(self, init_func, *args, **kwargs):
     self.klass = init_func
     self.args = args
     self.kwargs = kwargs
     self._initialized = None
     
 def __get__(self, instance, owner):
     if self._initialized is None:
         print('initialized!')
         self._initialized = self.klass(*self.args, **self.kwargs)
     else:
         print('cached!')
         return self._initialized
         

class WithSortedRandoms:
 lazily_initialized = InitOnAccess(sorted,[random.random() for _ in range(5)])

#### OutPut
#### >>> m = WithSortedRandoms()
#### >>> m.lazily_initialized
#### initialized!
#### [0.2592159616928279, 0.32590583255950756, 0.4015520901807743,
#### 0.4148447834912816, 0.4187058605495758, 0.4534290894962043,
#### 0.4796775578337028, 0.6963642650184283, 0.8449725511007807,
#### 0.8808174325885045]
#### >>> m.lazily_initialized
#### cached!
#### [0.2592159616928279, 0.32590583255950756, 0.4015520901807743,
#### 0.4148447834912816, 0.4187058605495758, 0.4534290894962043,
#### 0.4796775578337028, 0.6963642650184283, 0.8449725511007807,
#### 0.8808174325885045] 

import time
from queue import Queue, Empty
from threading import Thread

import requests

SYMBOLS = ('USD', 'EUR', 'PLN', 'NOK', 'CZK')
BASES = ('USD', 'EUR', 'PLN', 'NOK', 'CZK')

THREAD_POOL_SIZE = 4

def fetch_rates(base):
     response = requests.get(f"https://api.vatcomply.com/rates?base={base}")
     response.raise_for_status()
     rates = response.json()["rates"]
     
     # note: same currency exchanges to itself 1:1
     rates[base] = 1.
     return base, rates
     
def present_result(base, rates):
     rates_line = ", ".join([f"{rates[symbol]:7.03} {symbol}" for symbol in SYMBOLS ])
     print(f"1 {base} = {rates_line}")
     
def worker(work_queue, results_queue):
     while not work_queue.empty():
        try:
            item = work_queue.get_nowait()
        except Empty:
            break
            
        try:
            result = fetch_rates(item)
        except Exception as err:
            results_queue.put(err)
        else:
            results_queue.put(result)
        finally:
            work_queue.task_done()
       
def main():
     work_queue = Queue()
     results_queue = Queue()
     
     for base in BASES:
        work_queue.put(base)
        
     threads = [
        Thread(target=worker,args=(work_queue, results_queue) ) for _ in range(THREAD_POOL_SIZE)]
     
     for thread in threads:
        thread.start()
        
     work_queue.join()
     
     while threads:
        threads.pop().join()
        
     while not results_queue.empty():
        result = results_queue.get()
         if isinstance(result, Exception):
            raise result
            
        present_result(*results)
        
if __name__ == "__main__":
     started = time.time()
     main()
     elapsed = time.time() - started
     
     print()
     print("time elapsed: {:.2f}s".format(elapsed)) 

from multiprocessing import Process
import os

def work(identifier):
     print(
     f'Hey, I am the process '
     f'{identifier}, pid: {os.getpid()}'
     )
     
def main():
     processes = [
     Process(target=work, args=(number,))
     for number in range(5)
     ]
     for process in processes:
        process.start()
        
     while processes:
        processes.pop().join()
 
 if __name__ == "__main__":
    main()

import time
from multiprocessing import Pool

import requests

SYMBOLS = ('USD', 'EUR', 'PLN', 'NOK', 'CZK')
BASES = ('USD', 'EUR', 'PLN', 'NOK', 'CZK')

POOL_SIZE = 4

def fetch_rates(base):
     response = requests.get(
     f"https://api.vatcomply.com/rates?base={base}"
     )
     response.raise_for_status()
     rates = response.json()["rates"]
     # note: same currency exchanges to itself 1:1
     rates[base] = 1.
     return base, rates
     
 def present_result(base, rates):
     rates_line = ", ".join(
     [f"{rates[symbol]:7.03} {symbol}" for symbol in SYMBOLS]
     )
     print(f"1 {base} = {rates_line}")
     
def main():
     with Pool(POOL_SIZE) as pool:
        results = pool.map(fetch_rates, BASES)
        
     for result in results:
        present_result(*result)
 
if __name__ == "__main__":
 started = time.time()
 main()
 elapsed = time.time() - started
 
 print()
 print("time elapsed: {:.2f}s".format(elapsed))

from multiprocessing import Pool as ProcessPool
from multiprocessing.dummy import Pool as ThreadPool

def main(use_threads=False):
     if use_threads:
        pool_cls = ThreadPool
     else:
        pool_cls = ProcessPool
        
     with pool_cls(POOL_SIZE) as pool:
        results = pool.map(fetch_rates, BASES)
        
     for result in results:
        present_result(*result)
        
#### The dummy threading pool can also be imported from the multiprocessing.pool module as the ThreadPool class.
#### It will have the same implementation; 
#### the actual import path is just a matter of personal preference.

import asyncio
import random

async def print_number(number):
     await asyncio.sleep(random.random())
     print(number)
     
if __name__ == "__main__":
     loop = asyncio.get_event_loop()
     
     loop.run_until_complete(
        asyncio.gather(*[
            print_number(number)
            for number in range(10)
        ])
     )
     loop.close()
     
#### (the * operator) to unpack the list of coroutines as arguments

import asyncio
import time

import aiohttp

from asyncrates import get_rates

SYMBOLS = ('USD', 'EUR', 'PLN', 'NOK', 'CZK')
BASES = ('USD', 'EUR', 'PLN', 'NOK', 'CZK')

def present_result(base, rates):
     rates_line = ", ".join(
     [f"{rates[symbol]:7.03} {symbol}" for symbol in SYMBOLS]
     )
     print(f"1 {base} = {rates_line}")
 
async def main():
     async with aiohttp.ClientSession() as session:
         for result in await asyncio.gather(*[
         get_rates(session, base)
            for base in BASES
         ]):
         present_result(*result)
         
if __name__ == "__main__":
     started = time.time()
     
     loop = asyncio.get_event_loop()
     loop.run_until_complete(main())
     
     elapsed = time.time() - started
     
     print()
     print("time elapsed: {:.2f}s".format(elapsed))

>>> def loudly_return():
...     print("processing")
...     return 42
... 
>>> from concurrent.futures import ThreadPoolExecutor
>>> with ThreadPoolExecutor(1) as executor:
...     future = executor.submit(loudly_return)
...
processing
>>> future
<Future at 0x33cbf98 state=finished returned int>
>>> future.result()
42 

async def fetch_rates(base):
     loop = asyncio.get_event_loop()
     response = await loop.run_in_executor(
        None, requests.get,
        f"https://api.vatcomply.com/rates?base={base}"
     )
     response.raise_for_status()
     rates = response.json()["rates"]
     # note: same currency exchanges to itself 1:1
     rates[base] = 1.
     return base, rates

class Animal:
    """
    A class used to represent an Animal

    ...

    Attributes
    ----------
    says_str : str
        a formatted string to print out what the animal says
    name : str
        the name of the animal
    sound : str
        the sound that the animal makes
    num_legs : int
        the number of legs the animal has (default 4)

    Methods
    -------
    says(sound=None)
        Prints the animals name and what sound it makes
    """

    says_str = "A {name} says {sound}"

    def __init__(self, name, sound, num_legs=4):
        """
        Parameters
        ----------
        name : str
            The name of the animal
        sound : str
            The sound the animal makes
        num_legs : int, optional
            The number of legs the animal (default is 4)
        """

        self.name = name
        self.sound = sound
        self.num_legs = num_legs

    def says(self, sound=None):
        """Prints what the animals name is and what sound it makes.

        If the argument `sound` isn't passed in, the default Animal
        sound is used.

        Parameters
        ----------
        sound : str, optional
            The sound the animal makes (default is None)

        Raises
        ------
        NotImplementedError
            If no sound is set for the animal or passed in as a
            parameter.
        """

        if self.sound is None and sound is None:
            raise NotImplementedError("Silent Animals are not supported!")

        out_sound = self.sound if sound is None else sound
        print(self.says_str.format(name=self.name, sound=out_sound))

"""Spreadsheet Column Printer

This script allows the user to print to the console all columns in the
spreadsheet. It is assumed that the first row of the spreadsheet is the
location of the columns.

This tool accepts comma separated value files (.csv) as well as excel
(.xls, .xlsx) files.

This script requires that `pandas` be installed within the Python
environment you are running this script in.

This file can also be imported as a module and contains the following
functions:

    * get_spreadsheet_cols - returns the column headers of the file
    * main - the main function of the script
"""

import argparse

import pandas as pd


def get_spreadsheet_cols(file_loc, print_cols=False):
    """Gets and prints the spreadsheet's header columns

    Parameters
    ----------
    file_loc : str
        The file location of the spreadsheet
    print_cols : bool, optional
        A flag used to print the columns to the console (default is
        False)

    Returns
    -------
    list
        a list of strings used that are the header columns
    """

    file_data = pd.read_excel(file_loc)
    col_headers = list(file_data.columns.values)

    if print_cols:
        print("\n".join(col_headers))

    return col_headers


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        'input_file',
        type=str,
        help="The spreadsheet file to pring the columns of"
    )
    args = parser.parse_args()
    get_spreadsheet_cols(args.input_file, print_cols=True)


if __name__ == "__main__":
    main()

class Circle:
     def __init__(self, radius):
          self.radius = radius
     # Class implementation...
     
class Square:
     def __init__(self, side):
          self.side = side
     # Class implementation...
     
def shape_factory(shape_name, *args, **kwargs):
     shapes = {"circle": Circle, "square": Square}
     return shapes[shape_name](*args, **kwargs)
     
"""
>>> circle = shape_factory("circle", radius=20)
>>> type(circle)
<class '__main__.Circle'>
>>> circle.radius
20
>>> square = shape_factory("square", side=10)
>>> type(square)
<class '__main__.Square'>
>>> square.side
10
"""

def gen():
     yield 1
     yield 2
     return 3
"""
>>> g = gen()
>>> g
<generator object gen at 0x7f4ff4853c10>
>>> next(g)
1
>>> next(g)
2
>>> next(g)
Traceback (most recent call last):
File "<input>", line 1, in <module>
next(g)
StopIteration: 3
"""