# A Python program to return multiple 
# values from a method using tuple 

# This function returns a tuple 
def fun(): 
	str = "geeksforgeeks"
	x = 20
	return str, x # Return tuple, we could also 
					# write (str, x) 

# Driver code to test above method 
str, x = fun() # Assign returned tuple 
print(str) 
print(x) 

import time  
time.time_ns()

import concurrent.futures
#Define a function that will be executed in the thread pool
def my_function(arg):
    #Perform some long-running operation here
    result = arg * 2
    return result
#Create a thread pool object with 5 worker threads
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
    #Submit tasks to the thread pool using the submit() method
    future1 = executor.submit(my_function, 1)
    future2 = executor.submit(my_function, 2)
    future3 = executor.submit(my_function, 3)

    #Use the map() method to apply a function to a list of arguments
    queue = [4, 5, 6]
    results = executor.map(my_function, queue)

    #Wait for all tasks to complete using the shutdown() method
    executor.shutdown()

    #Get the results of each task using the result() method
    result1 = future1.result()
    result2 = future2.result()
    result3 = future3.result()
    #Print the results
    print(result1, result2, result3)
    print(list(results))

import sys
sys._is_gil_enabled()

from functools import partial

# A normal function
def f(a, b, c, x):
    return 1000*a + 100*b + 10*c + x

# A partial function that calls f with
# a as 3, b as 1 and c as 4.
g = partial(f, 3, 1, 4)

# Calling g()
print(g(5))

g_c = 0

class TestClass():
    def run(self):
        global g_c
        for i in range(10):
            g_c = 1
            print(g_c)

import inspect
this_function_name = inspect.currentframe().f_code.co_name
# or 
__name__
# or 
import inspect

def foo():
   print(inspect.stack()[0][3])
#stack()[0] is the caller
#stack()[3] is the string name of the method

import traceback
traceback.print_stack()
traceback.print_stack(file=sys.stdout)

import traceback

def f():
    g()

def g():
    for line in traceback.format_stack():
        print(line.strip())

f()

# Prints:
# File "so-stack.py", line 10, in <module>
#     f()
# File "so-stack.py", line 4, in f
#     g()
# File "so-stack.py", line 7, in g
#     for line in traceback.format_stack():

import inspect 
>>> print(inspect.stack()) 
[FrameInfo(frame=<frame at 0x7f8462b852d0, file '<stdin>', line 1, code <module>>, filename='<stdin>', lineno=1, function='<module>', code_context=None, index=None, positions=Positions(lineno=1, end_lineno=1, col_offset=6, end_col_offset=21))]

import regex as re 
# a line containing numbers 
re.search("[0-9]+", line)
# a line containing a keyword anywhere 
re.search("blk", line)

return len(c) == 0

>>> tuple_list = [('a', 1), ('b', 2), ('c', 3)] 
>>> d = dict(tuple_list)
>>> print(d) 
{'a': 1, 'b': 2, 'c': 3}
# or 
>>> h = {k:v for k,v in tuple_list}
>>> print(h) 
{'a': 1, 'b': 2, 'c': 3}
>>> 

# Returns None, if does not exist 
value = d.get(key)
# can provide a default value 
value = d.get(key, "empty")

>>> list = [1, 2, 3, 4, 5, 6, 8, 9 , 10]
# first 3 
>>> list[:3]
[1, 2, 3]
# except the last three 
>>> list[:-3]
[1, 2, 3, 4, 5, 6]
# the last three 
>>> list[-3:]
[8, 9, 10]
>>> 

    import platform 

    print('Uname:', platform.uname())
    print()    
    print('Machine :', platform.machine())
    print('Node :', platform.node())
    print('Processor :', platform.processor())
    print('Release :', platform.release())
    print('System :', platform.system())
    print('Version :', platform.version())
    print('Platform :', platform.platform())
    (major, minor, patch) = platform.release().strip().split('.')[:3]
    if int(major) != 6 or int(minor) != 9:
        term_size = os.get_terminal_size()
        print('#' * int(term_size.columns/2))
        print("WARNING: This code was written for the 6.9 kernel version, so please check the kprobe signatures in case you get bogus values.")
        print('#' * int(term_size.columns/2))

import os 
term_size = os.get_terminal_size()
print('_' * int(term_size.columns/2))

from parse import parse as p
dev_name = p("/dev/{}", ("/dev/loop0").strip(), case_sensitive=True)

L = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
for (idx, i) in zip(range(0, len(L)), L): 
    print(i, e)

# Make a null list 
xs = [None] * 10
# set all to zero 
[(lambda x: 0)(x) for x in [None] * 10]
# or an int list then square them 
last_values = [(lambda x: x*x)(x) for x in range(10)]
# o rjust directly create a list of all Zeros ;) like here with 256 
prev = [0] * 256

'{:<30}'.format('left aligned')
'left aligned                  '
'{:>30}'.format('right aligned')
'                 right aligned'
'{:^30}'.format('centered')
'           centered           '
'{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'

'{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
'{}, {}, {}'.format('a', 'b', 'c')  # 3.1+ only
'a, b, c'
'{2}, {1}, {0}'.format('a', 'b', 'c')
'c, b, a'
'{2}, {1}, {0}'.format(*'abc')      # unpacking argument sequence
'c, b, a'
'{0}{1}{0}'.format('abra', 'cad')   # arguments' indices can be repeated
'abracadabra'

cmd = '''while read -r x;
   do ping -c 3 "$x" | grep 'min/avg/max'
   done <hosts.txt'''

# Trivial but horrible
results = subprocess.run(
    cmd, shell=True, universal_newlines=True, check=True)
print(results.stdout)

# Reimplement with shell=False
with open('hosts.txt') as hosts:
    for host in hosts:
        host = host.rstrip('\n')  # drop newline
        ping = subprocess.run(
             ['ping', '-c', '3', host],
             text=True,
             stdout=subprocess.PIPE,
             check=True)
        for line in ping.stdout.split('\n'):
             if 'min/avg/max' in line:
                 print('{}: {}'.format(host, line))

>>> result:dict[str, int] = {}
>>> type(result) 
<class 'dict'>
>>> result:dict[str, int] = []
>>> type(result) 
<class 'list'>
>>> 

@dataclass
class Point:
    x: float
    y: float
    z: float = 0.0

p = Point(1.5, 2.5)
print(p)  # Point(x=1.5, y=2.5, z=0.0)

from typing import NamedTuple

class User(NamedTuple):
    name: str

class MyStruct(NamedTuple):
    foo: str
    bar: int
    baz: list
    qux: User

my_item = MyStruct('foo', 0, ['baz'], User('peter'))
print(my_item) # MyStruct(foo='foo', bar=0, baz=['baz'], qux=User(name='peter'))

>>> from datetime import datetime
>>> datetime.today().strftime('%Y-%m-%d')
'2021-01-26'

>>> datetime.today().strftime('%Y-%m-%d %H:%M:%S')
'2021-01-26 16:50:03'

error: externally-managed-environment

× This environment is externally managed
╰─> To install Python packages system-wide, try apt install
python3-xyz, where xyz is the package you are trying to
install.

If you wish to install a non-Debian-packaged Python package,
create a virtual environment using python3 -m venv path/to/venv.
Then use path/to/venv/bin/python and path/to/venv/bin/pip. Make
sure you have python3-full installed.

If you wish to install a non-Debian packaged Python application,
it may be easiest to use pipx install xyz, which will manage a
virtual environment for you. Make sure you have pipx installed.

See /usr/share/doc/python3.11/README.venv for more information.

note: If you believe this is a mistake, please contact your 
Python installation or OS distribution provider. You can override 
this, at the risk of breaking your Python installation or OS, 
by passing --break-system-packages.
hint: See PEP 668 for the detailed specification.

python3 -m venv .venv
source .venv/bin/activate
python3 -m pip install -r requirements.txt

(.venv) $ which python3 
/home/atr/src/.venv/bin/python3
(.venv) $ sudo which python3 
/usr/bin/python3
(.venv) $ sudo .venv/bin/python3 test.py -r --fio ~/src/fio/fio --dev /dev/nvme0n1

python3 -m venv .venv
echo .venv >> .gitignore # Should be in the ignore to prevent pushing a vm to git

source ./venv/bin/activate

pip3 freeze > requirements.txt

pip3 install -r requirements.txt

pip3 install matplotlib numpy notebook

import json

with open('fio_data.json') as f:
    d = json.load(f)
    print(d)

jupyter notebook