# 1a - will get printed only if var is False
if var is False:
    print('nice')

# 2 - will get printed in all Falsey conditions like None, [], {}, "", 0, 0.0
if not var:
    print('cool')

# 1 - true if a is not none
if a is not none:
    pass
# 2 - true if a is truthy
if a:
    pass

x, y = 10, 20
y, x = x, y
(x, y)

point = 10, 20, 30
x, y, z = point
(x, y, z)

for k, v in person_dictionary.items():
    print(k, v)
# ==>
for item in person_dictionary.items():
    k, v = item
    print(k, v)

# zip() example
for color, ratio in zip(colors, ratios):
    print(f"It's {ratio*100}% {color}.")

# In Python 3.0, the * operator was added to the multiple assignment syntax
numbers = [1, 2, 3, 4, 5, 6]
first, *rest = numbers
print(first)
print(rest)

# head, *middle, tail = numbers 

# Shallow Unpacking
color, point = ("red", (1, 2, 3))

# Deep Unpacking
color, (x, y, z) = ("red", (1, 2, 3))


items = [1, 2, 3, 4, 2, 1]
for i, (first, last) in enumerate(zip(items, reversed(items))):
    print(i, first, last)

# examples
# See also: https://needone.app/python-importing-explained/

├── main.py
└── src
    ├── bar
    │   └── bar.py
    ├── foo
    │   └── foo.py
    └── sample.py

# python src/foo/foo.py
# file's directory 'src/foo/' will be added to sys.path
# project root will not be added to sys.path
# Only absolute imports allowed, that too from file's current directory only

# python -m src.foo.foo
# project root will be added to sys.path
# foo.py module will have __package__ set to 'src.foo', similar for all modules in 'src'
# Because of this relative import will work on all modules in 'src'
# relative import will not work for module outside package 'src'(like main.py), for that just use absolute import(as project root is in sys.path)

# python -m main
# same as above just that main.py will still have __package__ = None, because of this relavite import will not work in main.py (or any other root level py files)
# Other subpackage level will have __package__ as expected, thus relative import will work within their top level package

x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
list(zipped)
# [(1, 4), (2, 5), (3, 6)]

list(map(lambda x: 'a '+ x, ['cat', 'dog', 'cow']))
# ['a cat', 'a dog', 'a cow']

list(filter(lambda x: 'o' in x, ['cat', 'dog', 'cow']))
# ['dog', 'cow']

from functools import reduce
reduce(lambda acc, x: f'{acc} | {x}', ['cat', 'dog', 'cow'])
# 'cat | dog | cow'

# map with list of iterables
map(lambda a, b: a+b, [1, 2, 3], [5, 15, 25])

sorted([5, 2, 3, 1, 4])
# [1, 2, 3, 4, 5]

sorted("This is a test string from Andrew".split(), key=str.lower)
# ['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']

student_tuples = [
    ('john', 'A', 15),
    ('jane', 'B', 12),
    ('dave', 'B', 10),
]
sorted(student_tuples, key=lambda student: student[2])
# [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

def write_data_to_json_file(data, file_path=None):
    if not file_path:
        from pathlib import Path
        # file_path = Path(__file__).parent.resolve()/'fb_test_users.json'
        # OR
        # generate dynamic file path
        from inspect import stack
        file_path = Path(__file__).parent.resolve()/'p_{}.json'.format(stack()[1][3])
    with open(file_path, 'w') as f:
        import json
        json.dump(data, f, indent=4)

# Serialization
with open(file_path, 'w') as f:
    data = {'person_id': 124}
    json.dump(data, f, indent=4)

# Deserialization
with open(file_path, 'r') as f:
    data = json.load(f)
    print(data)
    
# Trick: 
# Serialization --> to String

# Handle TypeError: Object of type datetime is not JSON serializable
json.dumps(my_dictionary, indent=4, sort_keys=True, default=str)

# See: https://stackoverflow.com/a/36142844

# permutations('ABCD', 2) --> AB AC AD BA BC BD CA CB CD DA DB DC
# permutations(range(3)) --> 012 021 102 120 201 210
itertools.permutations(iterable, r=None)


# combinations('ABCD', 2) --> AB AC AD BC BD CD
# combinations(range(4), 3) --> 012 013 023 123
itertools.combinations(iterable, r)

# combinations_with_replacement('ABC', 2) --> AA AB AC BB BC CC
itertools.combinations_with_replacement(iterable, r)


itertools.groupby(iterable, key=None)



itertools.product(iter_1, iter_2)

# Root Logger
import logging

logging.basicConfig(format='%(name)s - %(levelname)s - %(message)s')
logging.warning('Attention! This is a warning.')

# Simple Custom Logger (Preferred)
import logging

logger = logging.getLogger(__name__)

c_handler = logging.StreamHandler()
c_handler.setLevel(logging.WARNING)
c_handler.setFormatter(logging.Formatter('%(name)s - %(levelname)s - %(message)s'))
logger.addHandler(c_handler)

from contextlib import contextmanager

@contextmanager
def my_db_manager(db_path):
    # do setup here like getting, opening etc
    db_obj = get_db_obj_from_path(db_path)
    try:
        # this yield object will be assigned to variable after 'as' in 'with' statement
        yield db_obj
    finally:
        db_obj.close()

# usage
with my_db_manager("path/to/db") as db:
    print('doing something with db:', db)

# Above my_db_manager implemented using Custom Context Manager for a db
# NOTE: above my_db_manager is a method, but here it is a class
class my_db_manager:
    def __init__(self, db_path):
        self.db_path = db_path

    def __enter__(self):
        self.db_obj = get_db_obj_from_path(self.db_path)
        # NOTE:
        # if there is any exception raised inside with statement will not be called 
        # thus exit method also will not be called
        
        # this return object will be assigned to variable after 'as' in 'with' statement
        return self.db_obj

    def __exit__(self, *exc):
        self.db_obj.close()

# It lets you define a context manager using the class-based approach, but inheriting from contextlib.ContextDecorator. By doing so, you can use your context manager with the with statement as normal or as a function decorator. 
from contextlib import ContextDecorator

class makeparagraph(ContextDecorator):
    def __enter__(self):
        print('<p>')
        return self

    def __exit__(self, *exc):
        print('</p>')
        return False

@makeparagraph()
def emit_html():
    print('Here is some non-HTML')

emit_html()

p = re.compile('[a-z]+') # p is a pattern object
m = p.search('tempo') # m is a match object

<==>
m = re.search('[a-z]+', 'tempo')

# both type of fns accepts Compilation Flags like DOTALL, IGNORECASE

# This is same as if all ()s are removed
group() == group(0)

p = re.compile('(a(b)c)d')
m = p.match('abcd')
>>> m.group(0)
'abcd'
>>> m.group(1)
'abc'
>>> m.group(2)
'b'

# group() can be passed multiple group numbers at a time
>>> m.group(2,1,2)
('b', 'abc', 'b')

import re
from colorama import Back, Style


def highlight_regex_matches(pattern, text, print_output=True):
	output = text
	len_inc = 0
	for match in pattern.finditer(text):
		start, end = match.start() + len_inc, match.end() + len_inc
		output = output[:start] + Back.YELLOW + Style.BRIGHT + output[start:end] + Style.RESET_ALL + output[end:]
		len_inc = len(output) - len(text)  

	if print_output:
		print(output)
	else:
		return output