import random

random.seed(42)

import random

random.random()

random.uniform(0, 100)

from random import randint

randint(0, 9)

import numpy as np

np.random.randint(10, size=20)

import random

a = [random.randint(1, 10) for _ in range(20)]

random.choice([0, 1, 2])

py_rng_state = random.getstate()

pt_rng_state = torch.get_rng_state()

np_rng_state = numpy.random.get_state()

random.setstate(py_rng_state)

torch.set_rng_state(pt_rng_state)

numpy.random.set_state(np_rng_state)

https://regex101.com/

https://www.debuggex.com/

https://pythex.org/

re.I re.IGNORECASE ignore case

re.M re.MULTILINE make begin/end {^, $} consider each line

re.S re.DOTALL make . match newline too

re.U re.UNICODE make {\w, \W, \b, \B} follow Unicode rules

re.L re.LOCALE make {\w, \W, \b, \B} follow locale

re.X re.VERBOSE allow comments in regex, requires /s for spaces

()?iLmsux) set flags within regex

^ start of string

\A start of string, ignores m flag

$ end of string

\Z end of string, ignores m flag

\b word boundary

\B non-word boundary

(?=...) positive lookahead

(?!...) negative lookahead

(?<=...) positive lookbehind

(?<!...) negative lookbehind

(?()|) conditional

\g<0> Insert entire match

\g<Y> Insert match Y (name or number)

\Y Insert group numbered Y

isalnum()

isalpha()

isascii()

isdecimal()

isdigit()

isidentifier()

islower()

isnumeric() # checks if string is /^\d+$/

isprintable()

isspace()

istitle()

isupper()

"1".isdigit() # True

"a".isdigit() # False

buf = re.sub(r'^.*\r', '', buf, 0, re.M)

buf = re.sub(r'(\d)', r'\1_t', buf)

re.search("\db", "a1bc") # <re.Match object; span=(1, 3), match='1b'>

re.match(".*\db.*", "a1bc") # <re.Match object; span=(0, 4), match='a1bc'>

def my_replace(match):

match = match.group()

return match + str(match.index('e'))

out = re.sub(r'@\w+', my_replace, 'quick @red fox @lame') # 'quick @red2 fox @lame4'

lookup = {'1': 'one', '2': 'two', '3': 'three'}

s = "1 testing 2 3"

out = re.sub(r'\d', lambda x: lookup[x.group()], s)

match = re.findall(r'^(.*?//)([\w\.:]+)(.*)$', url)

if match: prot, domain, path = match[0]

words = re.split(r'[>=<]+', text)

words = re.split(r' *, *', text)

x = ["c<1.2.3","aa==1.3", "bb>=2.4.1"];

y = {k:v for k,v in (re.split(r"(?=\b[=<>].+)", d, 2) for d in x) }

{ k:v for k,v in list(re.findall(r"^([^=<>]+)([=<>]{,2}.*)", d, 2)[0] for d in x) }

s = s.replace('f', 'F')

s = s.replace('foo', 'bar')

s = s.strip()

"aaabbbccc".rpartition("bbb") # ("aaa", "bbb", "ccc")

"aaa bbb ccc".rsplit() # ("aaa", "bbb", "ccc")

"aaa-bbb-ccc".rsplit("-") # ("aaa", "bbb", "ccc")

"aaa-bbb-ccc".rsplit("-", 1) # ("aaa-bbb", "ccc")

'www.example.com'.strip('cmowz.') # 'example'

'#... Section 3.2.1 Issue #32 ...'.strip('.#! ') # 'Section 3.2.1 Issue #32'

re.escape(pat)

match = re.findall(rf'torch\s+: {re.escape(torch.__version__)}', buf)

import string

regex = re.compile(f'[{ re.escape(string.punctuation) }]')

regex.sub('', s)

regex = re.compile(f'[{ re.escape(string.punctuation) }]')

def text2words(s):

return (regex.sub('', s)

.strip()

.lower()

.replace(r'\n', ' ')

.replace(r'\r', ' ')

.split(' ')

)

stop_words = ['the', 'a', 'in', 'to']

stopwords_re = re.compile(fr'\b(?:{ "|".join(stop_words) })\b', re.I)

s = "The main feature in a tank"

s = re.sub(stopwords_re, '', s)

s = re.sub(r'\s+', ' ', s) # remove multiple spaces

s = s.strip() # edges

s # 'main feature tank'

import re, string, urllib, html

stop_words = ['the', 'a', 'in', 'to', 'of', 'and', 'i', 'is', 'on', 'for', 'you', 'it',

'with', 'by', 'that', 'at', 'this', 'from', 'are', 'be', 'up']

regex2remove = re.compile(f'[{ re.escape(string.punctuation) }]')

regex2space = re.compile('http\S+|\W+|[\n\r/#\|\?\-,]', re.I)

regexstopwords = re.compile(fr'\b(?:{ "|".join(stop_words) })\b', re.I)

def text2words(s):

s = s.lower()

s = urllib.parse.unquote(s) # unescape %20, etc.

s = html.unescape(s) # unescape &amp;, etc.

s = re.sub(regex2remove, '', s) # remove

s = re.sub(regex2space, ' ', s) # to space

s = re.sub(regexstopwords, '', s) # remove stopwords

s = re.sub(r'\s+', ' ', s) # remove multiple spaces

return s.lower().strip().split(' ')

text2words("foo%20bar http://x.to You and Me now!!!") # ['foo', 'bar', 'me', 'now']

import shlex;

print(shlex.split("squeue --user=$(getent group six | cut -d: -f4) -o \"%.16i %.9P %R\""))

if "the" in x

x.endswith('csv')

x.lower().endswith('csv')

x.startswith('The')

x.startswith(search_string, start, end)

x.endswith( search_string, start, end)

def findstem(arr):

n = len(arr)

s = arr[0]

l = len(s)

res = ""

for i in range(l):

for j in range(i + 1, l + 1):

# generating all possible substrings of our reference string arr[0] i.e s

stem = s[i:j]

k = 1

for k in range(1, n):

# Check if the generated stem is common to all words

if stem not in arr[k]:

break

# If current substring is present in all strings and its length is greater than current result

if (k + 1 == n and len(res) < len(stem)):

res = stem

return res

arr = ["grace", "graceful", "disgraceful", "gracefully"]

stems = findstem(arr)

print(stems) # grace

iconv -f utf-8 -t utf-8 -c bad.txt > good.txt

import ftfy

ftfy.fix_text('✔ No problems') # '✔ No problems'

import os

os.environ['MYVAR'] = "foo"

val = os.environ.get('MYVAR')

val = os.environ.get('MYVAR', 'fallback val')

if 'HOME' in os.environ: ...

for key in os.environ.keys():

if key.startswith("SLURM_"):

os.environ.pop(key)

python3 -c 'import os; [print(f"{k}={v}") for k,v in sorted(os.environ.items())]'

process = subprocess.Popen(['env', 'RSYNC_PASSWORD=foobar', 'rsync', 'rsync://username@foobar.com::'], stdout=subprocess.PIPE)

env = {'RSYNC_PASSWORD':'foobar'}

my_env = {**os.environ, **env}

subprocess.Popen(cmd, env=my_env)

my_env = os.environ.copy()

my_env["PATH"] = "/usr/sbin:/sbin:" + my_env["PATH"]

os.environ.pop('MYVAR', None)

python -c "$(echo -e "a='True'\nif a : print(1)")"

python -c "import torch; exec('with torch.cuda.device(0):\n x = torch.ones(10000,10000)')"

PYTHONPATH="$PWD/code" python ...

PYTHONPATH=`pwd`/src:$PYTHONPATH python -c 'import sys; print("\n".join(sys.path))'

import os

os.environ['PYTHONPATH']

if "FOO" in os.environ:

import os

bindir = os.path.abspath(os.path.dirname(__file__))

import pathlib

bindir = str(pathlib.Path(__file__).resolve().parent)

import sys

sys.path.insert(0, bindir) # take precedence

sys.path.append(bindir) # add at the end

import sys

from pathlib import Path

git_repo_path = Path(__file__).resolve().parents[3] / "src"

sys.path.insert(1, str(git_repo_path))

if str(git_repo_path) not in sys.path:

sys.path.insert(0, str(git_repo_path))

import sys

print("\n".join(sys.path))

import sys

from pathlib import Path

root_repo_path = Path(__file__).resolve().parents[2].as_posix()

if root_repo_path not in sys.path:

sys.path.insert(0, root_repo_path)

sys.path[1:1] = [path1, path2]

pathlib.Path(__file__).resolve().parents[1]

import os

os.path.realpath('.')

import pathlib, sys

pathlib.Path.cwd()

import os

path = "/tmp/foo/bar.py"

dirname, filename = os.path.split(path)

dirname = os.path.dirname(path) # /tmp/foo

filename = os.path.basename(path) # bar.py

import os

dir_path = os.path.dirname(os.path.realpath(__file__))

names = sorted(os.listdir(path))

list(Path(path).iterdir())

list(Path(path).glob('*'))

list(Path(path).rglob('*'))

list(Path(path).glob('**/'))

import inspect, os

caller__file__ = inspect.stack()[1][1]

def get_file_base_dir():

return os.path.abspath(os.path.dirname(caller__file__))

import os, sys

nb_dir = os.path.split(os.getcwd())[0]

if nb_dir not in sys.path: sys.path.append(nb_dir)

import ntpath

ntpath.basename("a/b/c.txt") # c.txt

from pathlib import Path

p = Path("a/b/c.txt")

print(p.stem) # c

print(p.name) # c.txt

print(p.suffix) # .txt

from shutil import copy2

copy2(f_in, f_out)

copy2(file, dir)

from pathlib import Path

filename = Path('/some/path/somefile.txt')

filename_replace_ext = filename.with_suffix('.jpg')

filename_wo_ext = filename.with_suffix('')

import sys

print(sys.modules['fastai'])

import inspect

inspect.getfile(self.__class__) # adjust to the desired class

import b

import inspect

print(inspect.stack()[6][1])

python a.py #

a.py

fname = Path(...)

fname_bak = fname.parent/f"{fname.name}.bak"

import os.path

os.path.exists(file_path)

os.path.isfile(file_path)

os.path.isdir(dir_path)

from pathlib import Path

path = Path(file_path)

path.exists()

path.is_file()

path.is_dir()

Path(path).touch()

Path(path).unlink(missing_ok=True)

os.remove(path)

os.unlink(path)

shutil.rmtree(tmp_dir, ignore_errors=True)

import os

os.rename('a.txt', 'b.kml')

import os

def path_is_parent(parent_path, child_path):

return parent_path == os.path.commonpath([parent_path, child_path])

p = "/tmp/xx/"

c1 = "/tmp/xx/yy"

c2 = "/tmp/xx1/yy"

path_is_parent(p, c1) # True

path_is_parent(p, c2) # False

from pathlib import Path

path = "tmp/foobar"

Path(path).mkdir(parents=True, exist_ok=True)

import os

os.makedirs(path, exist_ok=True)

if os.path.getmtime(src) < os.path.getmtime(dst):

print(f"{src} is newer than {dst}")

import shutil

def cmd_exists(cmd):

return shutil.which(cmd) is not None

import glob

glob.glob('./[0-9].*') # ['./1.gif', './2.txt']

from psutil import disk_partitions

from pathlib import Path

fs_types = {Path(r.mountpoint):r.fstype for r in disk_partitions(all=True)}

local_fs_types = ["ext", "ext2", "ext3", "ext4", "reiserfs", "jfs", "xfs", "zfs", "xfs", "btrfs", "ntfs", "overlay"]

def is_local_fs(path):

""" returns True if the path resides on the local fs or not """

return True if path_to_fs_type(path) in local_fs_types else False

def path_to_fs_type(path):

return path_to_fs_type(path.parent)

import tempfile

f = tempfile.NamedTemporaryFile(delete=False)

f.close()

tmp_file = f.name

os.unlink(tmp_file)

f = tempfile.NamedTemporaryFile(delete=False, dir=path)

fp = tempfile.TemporaryFile()

fp.write(b'Hello world!')

fp.close() # close the file, it will be removed

with tempfile.TemporaryFile() as fp:

fp.write(b'Hello world!')

import multiprocessing

def do_work(item):

print(f"processing item={item}")

pool = multiprocessing.Pool(num_workers)

pool.map(do_work, range(10))

pool.close()

pool.join()

import psutil

import threading

process = psutil.Process()

def cpu_mem_used(self):

"""get resident set size memory for the current process"""

return process.memory_info().rss

def peak_monitor_func(self):

break

peak_monitoring = True

peak_monitor_thread = threading.Thread(target=peak_monitor_func)

peak_monitor_thread.daemon = True

peak_monitor_thread.start()

import psutil

import os

def report_open_files(pid=None):

proc = psutil.Process(pid)

total = len(proc.open_files())

print(f"Total opened files: {total}")

def launch_open_files_monitor_2():

pool.join()

def launch_open_files_monitor(pid=None):

peak_monitor_thread.start()

def autocast_smart_context_manager(self):

return ctx_manager

with autocast_smart_context_manager(self):

do_something()

try:

from torch.distributed.elastic.multiprocessing.errors import record

except ImportError:

def record(fn): # noop

return fn

@record

def main():

do_something()

RecursionError: maximum recursion depth exceeded in comparison

import resource

import sys

print(resource.getrlimit(resource.RLIMIT_STACK)) # ( 8388608, -1)

print(sys.getrecursionlimit()) # 1000

resource.setrlimit(resource.RLIMIT_STACK, [0x4000000, resource.RLIM_INFINITY]) # (67108864, -1)

sys.setrecursionlimit(0x20000) # 8192

python -c 'import resource, sys; print(sys.getrecursionlimit(), resource.getrlimit(resource.RLIMIT_STACK))';

1000 ( 8388608, -1)

s = "ab\naa\ndd"

x = bytes(s, "utf-8").decode("unicode_escape")

print(x) # prints multiline

import fcntl

def printflock(*args, **kwargs):

fcntl.flock(fh, fcntl.LOCK_UN)

import sys

class multifile(object):

return g

sys.stdout = multifile([ sys.stdout, open('myfile.txt', 'w') ])

print 'abc'

print >>sys.stdout, 'line2'

sys.stdout.write('line3\n')

class Tee:

self.file.flush()

class Tee:

self.close()

import sys

print("This is error message")

sys.exit()

raise ValueError("This is error message")

if len(sys.argv) == 2 and os.path.exists(sys.argv[1]):

fn = sys.argv[1]

else:

print("Usage error: expecting a csv file as the only argument")

print("Usage: python program.py input.csv")

sys.exit()

import argparse

parser = argparse.ArgumentParser()

parser.add_argument('-l', '--linestring', action="store_true", help="connect dots")

parser.add_argument('-n', '--name', default="My Grid", help="project name",)

parser.add_argument('input', help='csv input file')

parser.add_argument('output', nargs='?', help='kml output file (optional)')

parser.add_argument('--ids', type=int, nargs='+')

parser.add_argument('--list',

default='all',

const='all',

nargs='?',

choices=['a', 'b', 'all'],

help='choices: default: all)')

args = parser.parse_args()

from pprint import pprint

pprint(vars(args))

import sys

import shlex

print(sys.executable, " ".join(map(shlex.quote, sys.argv)))

import os

import shlex

import sys

def get_orig_cmd(max_width=80, full_python_path=False):

return "\\\n".join(lines)