
from contextlib import contextmanager

@contextmanager
def highlighted_text():
    print('\033[2;31;43m', end='')
    try:
        yield
    finally:
        print("\033[0;0m", end='')


with highlighted_text():
    print("ciao")
print("mondo")

ciao
mondo


from itertools import cycle

def progress(iterator):
    cycling = cycle("⡇⣆⣤⣰⢸⠹⠛⠏")
    for element in iterator:
        print(next(cycling), end="\r")
        yield element
    print(" \r", end='')


import time
for idx in progress(range(10)):
    time.sleep(0.5)
print("finished!")

finished!


%%file .myapp_rc
[DEFAULT]
three=3

[OTHER]
a=3

Overwriting .myapp_rc


import configparser


config = configparser.ConfigParser()
config.read('.myapp_rc')

['.myapp_rc']


# it contains also the
list(config["OTHER"].items())

[('a', '3'), ('three', '3')]


# by default it will return lists
config["OTHER"]["a"]

'3'


# we can force it to return and int (or a float, or a bool)
config["OTHER"].getint("a")

3


%%bash
MY_ENV_VAR=1
echo $MY_ENV_VAR

1


%%bash
export MY_ENV_VAR=1
echo $MY_ENV_VAR
python -c "import os; print(os.environ['MY_ENV_VAR'])"

1
1


from collections import ChainMap


import os
default_config = dict(a='4', b='5')
final_config = ChainMap(os.environ, config["OTHER"], default_config)


# take it from the config file
final_config['a']

'3'


# take it from the default configuration
final_config['b']

'5'


from pathlib import Path


Path.home()

PosixPath('/home/enrico')


p = Path.home()/"didattica"/"programmingCourseDIFA"
p

PosixPath('/home/enrico/didattica/programmingCourseDIFA')


p.exists()

True


p.is_dir()

True


p.is_file()

False


list(p.iterdir())[:3]

[PosixPath('/home/enrico/didattica/programmingCourseDIFA/Lesson_08_Data_pipelines_and_Snakemake.html'),
 PosixPath('/home/enrico/didattica/programmingCourseDIFA/README.md'),
 PosixPath('/home/enrico/didattica/programmingCourseDIFA/Lesson_AF_09_random_sampling_and_statistics.slides.html')]


# simple globbing
list(p.glob("*.txt"))[:3]

[PosixPath('/home/enrico/didattica/programmingCourseDIFA/temp.txt'),
 PosixPath('/home/enrico/didattica/programmingCourseDIFA/Conda_Environment_instructions.txt')]


# recursive globbing
list(p.rglob("*.txt"))

[PosixPath('/home/enrico/didattica/programmingCourseDIFA/temp.txt'),
 PosixPath('/home/enrico/didattica/programmingCourseDIFA/Conda_Environment_instructions.txt'),
 PosixPath('/home/enrico/didattica/programmingCourseDIFA/divine_comedy/divina_commedia_with_copyright_notice.txt'),
 PosixPath('/home/enrico/didattica/programmingCourseDIFA/divine_comedy/divinacommedia_cleaned.txt')]


for item in p.iterdir():
    if item.is_dir():
        relative_item = item.relative_to(p)
        print(relative_item)

.ipynb_checkpoints
immagini
Lesson_01_introduction_files
Lesson_AF_03_continuous_time_random_walks_files
.mypy_cache
Lesson_AF_09_random_sampling_and_statistics_files
Lesson_09_DataFrame_and_Pandas_files
.git
Lesson_AF_02_Differential_Equations_analysis_files
divine_comedy
Lesson_06_Vectorization_files
Lesson_10_object_oriented_programming_sklearn_files
.snakemake
snakemake_exercise
Lesson_AF_01_random_generation_and_montecarlo_files
Lesson_07_Scientific_computation_libraries_files


p = Path('Lesson_AF_08_Documentation_and_API.ipynb')
p

PosixPath('Lesson_AF_08_Documentation_and_API.ipynb')


p.exists()

True


p.name

'Lesson_AF_08_Documentation_and_API.ipynb'


p.stem

'Lesson_AF_08_Documentation_and_API'


p.suffixes

['.ipynb']


p.with_suffix(".py")

PosixPath('Lesson_AF_08_Documentation_and_API.py')


p.absolute()

PosixPath('/home/enrico/didattica/programmingCourseDIFA/Lesson_AF_08_Documentation_and_API.ipynb')


p.absolute().relative_to(Path.home()/"didattica")

PosixPath('programmingCourseDIFA/Lesson_AF_08_Documentation_and_API.ipynb')


p = Path("non_existing_dir")
p.mkdir(exist_ok=True)
assert p.exists()
# before removing, the directory must be empty!
p.rmdir()
assert not p.exists()


%%file my_first_app.py

def mysum(a, b):
    return a+b

print("this will be executed everytime")

if __name__=='__main__':
    print("this will be executed only on the command line")

Writing my_first_app.py


# this execute a single python command and quit
!python -c "import my_first_app"

this will be executed everytime


!python ./my_first_app.py

this will be executed everytime
this will be executed only on the command line


%%file my_first_app.py
if __name__=='__main__':
    import sys
    print(sys.argv)

Overwriting my_first_app.py


!python ./my_first_app.py arg1 arg2

['./my_first_app.py', 'arg1', 'arg2']


%%file my_first_app.py
if __name__=='__main__':
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument("echo", help="echo the string you use here")
    
    args = parser.parse_args()
    
    print("the received string is: {}".format(args.echo))

Overwriting my_first_app.py


!python ./my_first_app.py --help

usage: my_first_app.py [-h] echo

positional arguments:
  echo        echo the string you use here

optional arguments:
  -h, --help  show this help message and exit


!python ./my_first_app.py to_be_said

the received string is: to_be_said


%%file my_first_app.py
if __name__=='__main__':
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument("echo", help="echo the string you use here")
    
    args = parser.parse_args()
    
    print("the received arguments are: {}".format(args))

Overwriting my_first_app.py


!python ./my_first_app.py to_be_said

the received arguments are: Namespace(echo='to_be_said')


%%file my_first_app.py
if __name__=='__main__':
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument("echo", help="echo the string you use here")
    args = parser.parse_args()
    args_dict = vars(args)
    assert isinstance(args_dict, dict)
    print(args_dict)

Overwriting my_first_app.py


!python ./my_first_app.py to_be_said

{'echo': 'to_be_said'}


%%file my_app.py
if __name__=='__main__':
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument("value", help="value to be squared", type=float)
    
    args = parser.parse_args()
    
    print(args.value**2)

Writing my_app.py


!python my_app.py --help

usage: my_app.py [-h] value

positional arguments:
  value       value to be squared

optional arguments:
  -h, --help  show this help message and exit


# type is used to enforce arguments type and convert them.
!python my_app.py 3

9.0


# type is used to enforce arguments type and convert them.
!python my_app.py a

usage: my_app.py [-h] value
my_app.py: error: argument value: invalid float value: 'a'


%%file my_app.py
if __name__=='__main__':
    import argparse
    parser = argparse.ArgumentParser()
    # positional arguments
    parser.add_argument("filename", help="file to be read")
    # named argument, default to False, True is present
    parser.add_argument("-v", "--verbose", help="increase output verbosity", action="store_true")
    
    args = parser.parse_args()
    
    print(f'I will now read the file "{args.filename}"')
    
    if args.verbose:
        print("Yadda "*30)

Overwriting my_app.py


!python my_app.py --help

usage: my_app.py [-h] [-v] filename

positional arguments:
  filename       file to be read

optional arguments:
  -h, --help     show this help message and exit
  -v, --verbose  increase output verbosity


!python my_app.py foo

I will now read the file "foo"


!python my_app.py foo --verbose

I will now read the file "foo"
Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda


!python3 my_app.py foo -v

I will now read the file "foo"
Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda Yadda


%%file my_app.py
if __name__=='__main__':
    import argparse
    parser = argparse.ArgumentParser()
    
    # positional arguments
    parser.add_argument("filename", help="file to be read")
    
    # named argument, default to False, True is present
    # has an optional short form
    parser.add_argument("-v", "--verbose", help="increase output verbosity", action="store_true")
    
    # named argument, takes a string as a value
    # has no short version
    parser.add_argument("--log-to-file", help="Sets the file into which logs will be emitted", type=str)
    
    args = parser.parse_args()
    
    print(f'I will now read the file "{args.filename}"')
    if args.log_to_file is not None:
        with open(args.log_to_file, 'w') as outfile:
            print("I will now read {0}".format(args.filename), file=outfile)
    
    if args.verbose:
        print("Yadda "*30)

Overwriting my_app.py


!python my_app.py foo

I will now read the file "foo"


!python my_app.py foo --log-to-file temp_log.txt

I will now read the file "foo"


!cat temp_log.txt

I will now read foo


%%file my_app.py
if __name__=='__main__':
    import argparse
    parser = argparse.ArgumentParser()
    subparsers = parser.add_subparsers(help='possible actions', dest='subparser')
    
    square_parser = subparsers.add_parser('pow', help='calculate the square power')
    square_parser.add_argument("value", help="value to be squared", type=float)
    # optional argument
    square_parser.add_argument("power", 
        help="power to raised at", 
        type=float,
        nargs='?', # this argument might be absent
        default=2, # the default value it takes if it absent
    )
    
    sqrt_parser = subparsers.add_parser('sqrt', help='calculate the square root')
    sqrt_parser.add_argument("value", help="value to be square rooted", type=float)
    
    args = parser.parse_args()
    print(args)

Overwriting my_app.py


!python my_app.py --help

usage: my_app.py [-h] {pow,sqrt} ...

positional arguments:
  {pow,sqrt}  possible actions
    pow       calculate the square power
    sqrt      calculate the square root

optional arguments:
  -h, --help  show this help message and exit


!python my_app.py pow --help

usage: my_app.py pow [-h] value [power]

positional arguments:
  value       value to be squared
  power       power to raised at

optional arguments:
  -h, --help  show this help message and exit


!python my_app.py sqrt --help

usage: my_app.py sqrt [-h] value

positional arguments:
  value       value to be square rooted

optional arguments:
  -h, --help  show this help message and exit


!python my_app.py pow 1

Namespace(power=2, subparser='pow', value=1.0)


%%file my_app.py
import argparse

def main_square(args):
    print(args.value**args.power)
    
def main_sqrt(args):
    print(args.value**0.5)

def main():
    parser = argparse.ArgumentParser()
    subparsers = parser.add_subparsers(help='possible actions', dest='subparser')
    
    square_parser = subparsers.add_parser('pow', help='calculate the square power')
    square_parser.add_argument("value", help="value to be squared", type=float)
    # optional argument
    square_parser.add_argument("power", 
        help="power to raised at", 
        type=float,
        nargs='?', # this argument might be absent
        default=2, # the default value it takes if it absent
    )
    
    sqrt_parser = subparsers.add_parser('sqrt', help='calculate the square root')
    sqrt_parser.add_argument("value", help="value to be square rooted", type=float)
    
    args = parser.parse_args()
    
    if args.subparser=='pow':
        main_square(args)
    if args.subparser=='sqrt':
        main_sqrt(args)
        
if __name__=='__main__':
    main()

Overwriting my_app.py


!python my_app.py pow 4

16.0


!python my_app.py pow 2 3

8.0


!python my_app.py sqrt 4

2.0


!mkdir -p myapp/myapp/
!touch ./myapp/myapp/__init__.py


%%file ./myapp/myapp/__main__.py
import argparse

def main_square(args):
    print(args.value**args.power)
    
def main_sqrt(args):
    print(args.value**0.5)

def main():
    parser = argparse.ArgumentParser()
    subparsers = parser.add_subparsers(help='possible actions', dest='subparser')
    
    square_parser = subparsers.add_parser('pow', help='calculate the square power')
    square_parser.add_argument("value", help="value to be squared", type=float)
    # optional argument
    square_parser.add_argument("power", 
        help="power to raised at", 
        type=float,
        nargs='?', # this argument might be absent
        default=2, # the default value it takes if it absent
    )
    
    sqrt_parser = subparsers.add_parser('sqrt', help='calculate the square root')
    sqrt_parser.add_argument("value", help="value to be square rooted", type=float)
    
    args = parser.parse_args()
    
    if args.subparser=='pow':
        main_square(args)
    if args.subparser=='sqrt':
        main_sqrt(args)
        
if __name__=='__main__':
    main()

Overwriting ./myapp/myapp/__main__.py


%%file ./myapp/setup.py
from setuptools import setup

setup(
    name = 'myapp',
    version = '0.1.0',
    packages = ['myapp'],
    #install_requires = ["required_package", ],
    entry_points = {
        'console_scripts': [
            'myapp = myapp.__main__:main',
        ]
    })

Overwriting ./myapp/setup.py


!pip install --editable myapp

Obtaining file:///home/enrico/didattica/programmingCourseDIFA/myapp
Installing collected packages: myapp
  Running setup.py develop for myapp
Successfully installed myapp


!myapp --help

usage: myapp [-h] {pow,sqrt} ...

positional arguments:
  {pow,sqrt}  possible actions
    pow       calculate the square power
    sqrt      calculate the square root

optional arguments:
  -h, --help  show this help message and exit


!myapp sqrt 9

3.0


!pip uninstall -y myapp

Found existing installation: myapp 0.1.0
Uninstalling myapp-0.1.0:
  Successfully uninstalled myapp-0.1.0


from subprocess import run, PIPE
run(["pwd"],
    stdout=PIPE,
    stdin=PIPE,
    stderr=PIPE,
    text=True,
)

CompletedProcess(args=['pwd'], returncode=0, stdout='/home/enrico/didattica/programmingCourseDIFA\n', stderr='')


# encoding was introduced in python 3.6
# capture_output was introduced in python 3.7
import subprocess
from subprocess import run
result = run(["python", "--version"], capture_output=True, encoding='utf8')
print(repr(result.stdout))
print(repr(result.stderr))
print(result.returncode)

'Python 3.9.12\n'
''
0


# multiple commands
run(["echo ciao; echo bello"],
    stdout=PIPE,
    stdin=PIPE,
    stderr=PIPE,
    text=True,
    shell=True,
)

CompletedProcess(args=['echo ciao; echo bello'], returncode=0, stdout='ciao\nbello\n', stderr='')


# shell piping
run(["ls *.ipynb | wc -l"],
    stdout=PIPE,
    stdin=PIPE,
    stderr=PIPE,
    text=True,
    shell=True,
)

CompletedProcess(args=['ls *.ipynb | wc -l'], returncode=0, stdout='20\n', stderr='')


from subprocess import Popen


def execute(*args):
    return Popen(args, stdout=PIPE, stdin=PIPE, stderr=PIPE, text=True)


p = execute("echo", "ciao")
p.communicate()

('ciao\n', '')


p.returncode

0


p = execute("sleep", "2")
if p.poll() is None:
    print("still sleeping")

still sleeping


if p.poll() is None:
    print("still sleeping")
else:
    print("finished sleeping")

finished sleeping


%%file temp.py
name = input("tell me your name:")
print("hello", name)

Overwriting temp.py


result = run(["python", "temp.py"], input='enrico\n', capture_output=True, encoding='utf8')
result

CompletedProcess(args=['python', 'temp.py'], returncode=0, stdout='tell me your name:hello enrico\n', stderr='')


# The example reproduces the command line:
# $ cat index.rst | grep ".. literal" | cut -f 3 -d:
import subprocess as sp

cat = sp.Popen(['cat', 'index.rst'], stdout=sp.PIPE,)
grep = sp.Popen(['grep', '.. literal::'], stdin=cat.stdout, stdout=sp.PIPE,)
cut = sp.Popen(['cut', '-f', '3', '-d:'], stdin=grep.stdout, stdout=sp.PIPE,)
end_of_pipe = cut.stdout

print('Included files:')
for line in end_of_pipe:
    print(line.decode('utf-8').strip())


import tempfile


tf = tempfile.NamedTemporaryFile(dir=".")
tf.name

'/home/enrico/didattica/programmingCourseDIFA_repo/master/tmpvlv7cbhl'


temp_path = tempfile.TemporaryDirectory(dir=".")
temp_path

<TemporaryDirectory './tmp0f3r8h3i'>


%%file temp.py
import sys
print("arguments", sys.argv)
with open(sys.argv[1], "w") as outfile:
    print("printed to file!", file=outfile)

Overwriting temp.py


with tempfile.NamedTemporaryFile(dir=".", mode='w+') as result_file:
    result = run(["python", "temp.py", str(result_file.name)], capture_output=True, encoding='utf8')
    print(result.stdout)
    lines = result_file.readlines()
print("printed in file:", lines)

arguments ['temp.py', '/home/enrico/didattica/programmingCourseDIFA_repo/master/tmp1awoy0t6']

printed in file: ['printed to file!\n']


%%file temp.py
import sys

for line in map(str.strip, sys.stdin):
    s = '-- ' + line + ' --'
    print(s, file=sys.stdout)

Overwriting temp.py


!echo 1|python temp.py

-- 1 --


import fileinput
for line in fileinput.input():
    process(line)


%%file temp.py
import sys, json, glob

patterns = sys.argv[1:]
for each_pattern in patterns:
    filenames = glob.glob(each_pattern)
    for each_filename in filenames:
        data = {'filename': each_filename, "pattern": each_pattern}
        # json.dumps takes a python structure and transform in a JSON string
        json_str = json.dumps(data)
        print(json_str, file=sys.stdout)

Overwriting temp.py


!python temp.py *.py *.svg

{"filename": "temp.py", "pattern": "*.py"}
{"filename": "test.py", "pattern": "*.py"}
{"filename": "directory_structure.svg", "pattern": "*.svg"}
{"filename": "file_inode_permissions.svg", "pattern": "*.svg"}
{"filename": "OS_structure.svg", "pattern": "*.svg"}
{"filename": "users_and_groups.svg", "pattern": "*.svg"}


%%file count_by.py
import sys, json, glob
from collections import Counter
counts = Counter()
pattern = sys.argv[1]

for line in map(str.strip, sys.stdin):
    # json.dumps takes a JSON string and transform in a python structure
    data = json.loads(line)
    value = data[pattern]
    counts[value] += 1
    
json_str = json.dumps(counts)
print(json_str, file=sys.stdout)

Overwriting count_by.py


!python temp.py *.py *.svg | python count_by.py pattern

{"*.py": 3, "*.svg": 4}


!python -c "from glob import glob;print(*glob('*.py'), sep='\n')"

count_by.py
JSONifier.py
temp.py
test.py


%%file JSONifier.py
import sys, json
pattern = sys.argv[1]
for line in map(str.strip, sys.stdin):
    data = {pattern: line}
    json_str = json.dumps(data)
    print(json_str, file=sys.stdout)

Overwriting JSONifier.py


!python -c "from glob import glob;print(*glob('*.py'), sep='\n')" | python JSONifier.py filename

{"filename": "count_by.py"}
{"filename": "JSONifier.py"}
{"filename": "temp.py"}
{"filename": "test.py"}


import math
print("{:.4}".format(math.pi))

3.142


print('L {:<20} R'.format('x'))
print('L {:^20} R'.format('x'))
print('L {:>20} R'.format('x'))

L x                    R
L          x           R
L                    x R


print ('{:=<20}'.format('hello'))
print ('{:_^20}'.format('hello'))
print ('{:.>20}'.format('hello'))

hello===============
_______hello________
...............hello


users = [["Alice", 20],
         ["Bob", 30],
         ["Carol", 25],
         ["Dave", 32],
        ]
columns = ["name", "age"]


print('{:<10s}{:>4s}'.format(*columns))
for name, age in users:
    print('{:<10s}{:>4d}'.format(name, age))

name       age
Alice       20
Bob         30
Carol       25
Dave        32


# use the vertical and horizontal lines to format it according to
# markdown syntax, so that you can have nicely formatted text
print('|{:<10s}|{:>4s}|'.format(*columns))
print('|{:<10s}|{:>4s}|'.format('-'*10, '-'*4))
for name, age in users:
    print('|{:<10s}|{:>4d}|'.format(name, age))

|name      | age|
|----------|----|
|Alice     |  20|
|Bob       |  30|
|Carol     |  25|
|Dave      |  32|


# you can use variables to set the formatting by enclosing 
# the name in curly brackets inside the other curly brakets!
size1, size2 = 8, 4
print('|{:<{s1}s}|{:>{s2}s}|'.format(*columns, s1=size1, s2=size2))
print('|{:<{s1}s}|{:>{s2}s}|'.format('-'*size1, '-'*size2, s1=size1, s2=size2))
for name, age in users:
    print('|{:<{s1}s}|{:>{s2}d}|'.format(name, age, s1=size1, s2=size2))

|name    | age|
|--------|----|
|Alice   |  20|
|Bob     |  30|
|Carol   |  25|
|Dave    |  32|


import textwrap


s = "some crazy long string that we might need to break on multiple lines"
print(textwrap.fill(s, 15))

some crazy long
string that we
might need to
break on
multiple lines


s = "another craxy string to be hidden"
textwrap.shorten(s, width=19, placeholder=" [...]")

'another craxy [...]'


%%file temp.py
from sys import stdout
with open("temp.txt", "w") as outfile:
    if stdout.isatty():
        print('The output device is a teletype. Or something like a teletype.', file=outfile)
    else:
        print("The output device isn't like a teletype.", file=outfile)

Overwriting temp.py


result = run(["python", "temp.py"], input='enrico\n', capture_output=True, encoding='utf8')
with open("temp.txt") as file:
    for line in file:
        print(line.strip())

The output device isn't like a teletype.


result = run(["python", "temp.py"], input='enrico\n', encoding='utf8')
with open("temp.txt") as file:
    for line in file:
        print(line.strip())

The output device is a teletype. Or something like a teletype.


def dot_format(number, left_pad, right_pad, padding=''):
    big, small = str(float(number)).split('.')
    format_str = "{b:>{s1}s}.{s:{pad}<{s2}s}"
    result = format_str.format(
        b=big,
        s=small,
        pad=padding,
        s1=left_pad,
        s2=right_pad)
    return result


print(dot_format(2, left_pad=2, right_pad=3))
print(dot_format(3.14, left_pad=2, right_pad=3))
print(dot_format(12.1, left_pad=2, right_pad=3))

 2.0  
 3.14 
12.1


print(dot_format(2, left_pad=2, right_pad=3, padding='0'))
print(dot_format(3.14, left_pad=2, right_pad=3, padding='0'))
print(dot_format(12.1, left_pad=2, right_pad=3, padding='0'))

 2.000
 3.140
12.100


from functools import partial
my_format = partial(dot_format, left_pad=2, right_pad=3, padding='0')
numbers = [2, 3.14, 12.127]
for each_number in numbers:
    print(my_format(each_number))

 2.000
 3.140
12.127


print('\U0001F606') 
print("👍")

😆
👍


import getpass
pwd = getpass.getpass(prompt='Password: ')
print(pwd)

Password: ········
ciao


import smtplib, ssl, getpass

port = 587
smtp_server = "smtp.office365.com"
user = "enrico.giampieri@unibo.it"
password = getpass.getpass(prompt='Password: ')

receiver = "enrico.giampieri@unibo.it"
# the empty line divides the header from the body
msg = """Subject: Hi there

This message is sent from Python.
"""


# Create a secure SSL context
context = ssl.create_default_context()
with smtplib.SMTP(smtp_server, port) as server:
    # Secure the connection
    server.starttls(context=context) 
    server.login(user, password)
    server.sendmail(user, receiver, msg)


from cryptography.fernet import Fernet
salt = b"myusername" # this should depend on the username or the domain, don't always use the same
key = Fernet.generate_key() # save this!!!
message = b"my_important_password"

cipher_suite = Fernet(key)
salted_message = salt+message # this is a very trivial salting, could use something smarter
cipher_text = cipher_suite.encrypt(salted_message)

print(cipher_text)

salted_text = cipher_suite.decrypt(cipher_text)
plain_text = salted_text[len(salt):] # inverse operation of the salting
assert plain_text == message

b'gAAAAABewB2M-k1o9Eh4aBpEnWXc1YvZUncNuXe7_B1ZU6Ym7waVA0JynvRLktfL5igCekLg4ZVQrO9S33tj2lEUHT9CB5F_FfcFE-Gj8JjcSM4VeTJBTds='

key

b'r-62ZvVmkg_L1UiaeU7pK6N4uOW36y1Ybhtm9Y_okZw='


bar = '▁▂▃▄▅▆▇█'
barcount = len(bar)
 
def sparkline(numbers):
    mn, mx = min(numbers), max(numbers)
    extent = mx - mn
    sparkline = ''.join(bar[min([barcount - 1,
                                 int((n - mn) / extent * barcount)])]
                        for n in numbers)
    return mn, mx, sparkline

data = [8, 2, 3, 5, 1, 1, 4]
mn, mx, sp = sparkline(data)
print(sp)

█▂▃▅▁▁▄


data = [8, 2, 3, 5, 1, 1, 4]
for each_value in data:
    print("="*each_value, each_value)

======== 8
== 2
=== 3
===== 5
= 1
= 1
==== 4


blocks=  "▀▁▂▃▄▅▆▇█▉▊▋▌▍▎▏▐░▒▓▔▕▖▗▘▙▚▛▜▝▞▟"
# https://en.wikipedia.org/wiki/Geometric_Shapes
symbols_set_1 = "■□▢▣▤▥▦▧▨▩▪▫▬▭▮▯"
symbols_set_2 = "▰▱▲△▴▵▶▷▸▹►▻▼▽▾▿"
symbols_set_3 = "◀◁◂◃◄◅◆◇◈◉◊○◌◍◎●"
symbols_set_4 = "◐◑◒◓◔◕◖◗◘◙◚◛◜◝◞◟"
symbols_set_5 = "◠◡◢◣◤◥◦◧◨◩◪◫◬◭◮◯"
symbols_set_6 = "◰◱◲◳◴◵◶◷◸◹◺◻◼◽◾◿"
# tables and box drawing
# https://en.wikipedia.org/wiki/Box_Drawing_(Unicode_block)
box_borders_1_of_many = "─━│┃┄┅┆┇┈┉┊┋┌┍┎┏"
# arrows and symbols
# https://en.wikipedia.org/wiki/Miscellaneous_Symbols_and_Arrows
arrows_1_of_many = "⬀⬁⬂⬃⬄⬅⬆⬇⬈⬉⬊⬋⬌⬍⬎⬏"
#https://en.wikipedia.org/wiki/Mathematical_operators_and_symbols_in_Unicode
math_1_of_too_many = "∀∁∂∃∄∅∆∇∈∉∊∋∌∍∎∏"
superscripts = "⁰¹²³⁴⁵⁶⁷⁸⁹" + "ⁱ ⁺ ⁻ ⁼ ⁽ ⁾ ⁿ"
underscripts = "₀₁₂₃₄₅₆₇₈₉ ₊ ₋ ₌ ₍ ₎" + "ₐₑₒₓₔₕ ₖ ₗ ₘ ₙ ₚ ₛ ₜ "
greek_letters= "αβγ…" # and all the others


print("a\b")

a


print("a\r")

a


print("aa\rb")

b


from itertools import cycle
from time import sleep

for idx, frame in enumerate(cycle(r'-\|/-\|/')):
    print('\r', frame, sep='', end='', flush=True)
    sleep(0.2)
    if idx>30:
        print('\r', ' ', sep='', end='', flush=True)
        break


# play a chime sound, useful to signal the end of some operation
print('\a')




import locale
import os
# Default settings based on the user's environment.
locale.setlocale(locale.LC_ALL, '')

# What is the locale?
print('\nLocale from environment:', locale.getlocale())

Locale from environment: ('English_United States', '1252')


sample_locales = [
    ('UK', 'en_GB'),
    ('France', 'fr_FR'),
    ('China', 'zh-cn'),
    ('Italy', 'it_IT'),
    ('Poland', 'pl_PL'),
]


for name, loc in sample_locales:
    locale.setlocale(locale.LC_ALL, loc)
    print('{:>13}: {:>13}  {:>13}'.format(
        name,
        locale.currency(1234.5678),
        locale.currency(-1234.5689),
    ))

           UK:      £1234.57      £-1234.57
       France:     1234,57 €     -1234,57 €
        China:      ￥1234.57      ￥1234.57-
        Italy:     1234,57 €     -1234,57 €
       Poland:    1234,57 zł    -1234,57 zł


print('{:>10} {:>10} {:>15}'.format('Locale', 'Integer', 'Float'))
for name, loc in sample_locales:
    locale.setlocale(locale.LC_ALL, loc)

    print('{:>10}'.format(name), end=' ')
    print(locale.format_string('%10d', 123456, grouping=True), end=' ')
    print(locale.format_string('%15.2f', 123456.78, grouping=True))

    Locale    Integer           Float
        UK    123,456      123,456.78
    France    123 456      123 456,78
     China    123,456      123,456.78
     Italy    123.456      123.456,78
    Poland    123 456      123 456,78

writing command line applications¶

Why applications?¶

CLI application good practices¶

Errors management¶

clean up after yourself, especially on errors¶

allow if possible to recover partial results¶

try to be robust to bad data and configuration¶

Exit with different error codes¶

User interaction¶

give feedback for task longer than a second or two (such as progress bars)¶

let the user control the level of verbosity of the output¶

Colour code your output¶

Have both short ie one letter (Eg -h) and long forms (eg --help) of the command's switches¶

Ask for confirmation for irreversible action¶

Documentation¶

consider adding a help sub command¶

provide some use cases in the documentation¶

In case of mistakes try suggesting common correction techniques¶

make common commands memorable¶

Configuration¶

Work independently of current working directory¶

consider using configuration files¶

all the options that can have a default value, should have one¶

Interface¶

try to be consistent with other GNU tools :¶

play well with pipes and allow input and output to files¶

If a command has a side effect provide a dry-run/whatif/no_post option.¶

everything should be doable in a script, without human interaction¶

try to make it composable¶

conside adding switches to both turn on and off behaviors¶

consider using a long informative name for you app¶

if no output is necessary, avoid output unless required¶

Preface - utilities¶

colored text output¶

note on windows terminal¶

progress bars¶

configurations files and defaults¶

configuration files¶

environment variables¶

chaining configuration¶

reading user input¶

Path objects¶

Command line programs¶

Command line arguments structure¶

using flags¶

sub commands¶

Subcommands in practice¶

system wide installation¶

preparing the field¶

the installation step¶

Testing CLI¶

executing local programs - subprocesses¶

blocking execution¶

running shell lines¶

non-blocking execution¶

testing filesystem I/O¶

Input and Output of CLI programs¶

MapReduce philosophy¶

Printing for Machines¶

Printing for Humans¶

tetwrapping - adatting to different terminal lenght¶

Differentiate output if on terminal or not¶

dot aligned numbers¶

Special characters¶

inputting passwords¶

final readings¶

Exercise¶

advanced¶

Extra Material¶

sending email from the script¶

Spark plots¶

Notifications¶

Internationalization (i18n)¶

Have both short ie one letter (Eg `-h`) and long forms (eg `--help`) of the command's switches¶

consider adding a `help` sub command¶