Python Notes

wget https://bootstrap.pypa.io/get-pip.py # Download installation script
python3 get-pip.py # Run installation script

def print_lines(file):
    with open(file) as f:
        for line in f:
            print(line)

def return_list(file):
    with open(file) as f:
        list = f.readlines()
        return list

def remove_line_containing_string(file):
    f = open(file, 'r')
    contents = f.readlines()
    f.close()

    f = open(file, 'w')
    for line in contents:
        if not 'some string' in line:
            f.write(line)
    f.close()

def file_exists(file):
    if os.path.isfile(file):
        return True
    else:
        return False

def find_and_replace_in_file(inp_file, old, new):
    new_output = ''
    with open(inp_file, 'U') as f:
        new_output = f.read()

        while old in new_output:
            new_output = new_output.replace(old, new)

    with open(inp_file, 'w') as f:
        f.write(new_output)

import subprocess

def run_cmd(cmd):
    p = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)x
    output, err = p.communicate()
    return output.decode().strip()

# Example:
print(run_cmd("uname -a"))

python3 -m http.server <port>

from http.server import HTTPServer, SimpleHTTPRequestHandler
import socket

class HTTPServerV6(HTTPServer):
    address_family = socket.AF_INET6

server = HTTPServerV6(('::', 8080), SimpleHTTPRequestHandler)
server.serve_forever()

python -m SimpleHTTPServer <port>

import getpass

try:
    password = getpass.getpass()
except Exception as error:
    print('ERROR', error)

>>> import re
>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m.group(0)
'Isaac Newton'
>>> m.group(1)
'Isaac'
>>> m.group(2)
'Newton'
>>> m.group(1,2)
('Isaac', 'Newton')

# input could be something like:
# dog 2
pattern = re.compile("\w+(\d+)")
with open(file) as f:
    for line in f:
      m = pattern.match(line)
      if m:
        print(f"Found this item: {m.group(1)}")

>>> l = [1,2,3,4]
>>> rl = l[::-1]
>>> rl
[4, 3, 2, 1]

a_list = ["a", "b", "c"]
joined_string = ",".join(a_list)

if not a:
  print("List is empty")

<string var>[2:]

from os import listdir
from os.path import isfile, join
onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]

os.remove('path/to/file')

os.chdir('/etc/')

if os.path.isdir(self.repo_name):
    shutil.rmtree(self.repo_name)

import glob, os
for f in glob.glob("*.jpg"):
    os.remove(f)

from pathlib import Path
for p in Path(".").glob("*.jpg"):
    p.unlink()

os.system('ls')

from mypyutils import sysutils

output = sysutils.run_cmd('aws ec2 describe-images --filters \
            "Name=name,Values=Kali-X2Go" --output json')

for x in range(int(sp),int(ep)+1):
    port_scan(site,int(x))

all_my_ideas = {idea:ideas.count(idea) for idea in ideas if len(idea) > 4}

print(list[0])

import os
site = 'https://google.com'
os.system(f"open -a /Applications/Google\ Chrome.app {site}")

>>> foo = 'test'
>>> f'{foo} {{bar}}'
'test {bar}'

import os
site = 'https://google.com'
os.system("open -a /Applications/Google\ Chrome.app %s" % site)

with open(file) as f:
    for line in f:
        print(run_cmd("nmap --open -Pn -top-ports 1000 -T4 -sS -g80 -sC -sV {target}".format(target=line)))

list = [
    'item1',
    'item2',
]

pip freeze > requirements.txt

import pdb; pdb.set_trace()

globals()

!import code; code.interact(local=vars())

dir(object)

type(object)

obj.rstrip().replace('"', '')

'blablabla\r\n'.strip()

def check_root():
    if not os.geteuid() == 0:
        sys.exit('This script must be run as root!')

import paramiko

k = paramiko.RSAKey.from_private_key_file("/path/to/pem/file")
c = paramiko.SSHClient()
c.set_missing_host_key_policy(paramiko.AutoAddPolicy())
c.connect( hostname = "<ec2 hostname>", username = "<username>", pkey = k )

stdin , stdout, stderr = c.exec_command("<command to run>")
print("stdout: " + stdout.read().decode('utf-8'))
print("stderr" + stderr.read().decode('utf-8'))
c.close()

pip3 install -U pipenv

pipenv --python 3.6.5

pipenv install <package>

pipenv lock

pipenv run python -V
pipenv run python -c 'print("A" * 32)'

pipenv shell

pipenv --rm

pipenv install -r requirements.txt

brew install pyenv
echo 'PATH=$(pyenv root)/shims:$PATH' >> ~/.zshrc

PY_VER=3.8.12
pyenv install "${PY_VER}"

PY_VER=3.8.12
pyenv local "${PY_VER}"

pyenv versions

PY_VER=3.8.12
pyenv global "${PY_VER}"

pip install pip-licenses

>>> s = "dedjdedl"
>>> s.index('d')
0
>>> s.rindex('d')
6

>>> l1 = ['a','b','c']
>>> l2 = [1,2,3]
>>> print(list(zip(l1,l2)))
[('a', 1), ('b', 2), ('c', 3)]

combined = zip(list1, list2)
for list1, list2 in combined:
    print(list1)

>>> a = [[1,2],[3,4],[5,6]]
>>> print(list(zip(*a)))
[(1, 3, 5), (2, 4, 6)]

>>> items = [1,5,2,2,3,5,1]
>>> set(items)
{1, 2, 3, 5}

for idx, val in enumerate(list_of_stuff):
    print(idx)
    print(val)

for i in range(start, end, 100):

import random
print(random.randint(1,101))

with fileinput.FileInput("file.txt", inplace=True) as file:
        for line in file:
            print(line.replace('stringtoreplace', 'replacementstring'), end='')

def id_generator(size=20, chars=string.ascii_lowercase + string.digits):
    return ''.join(random.choice(chars) for _ in range(size))

run_cmd(f"gnome-terminal --tab --active -- bash -c 'ls ; exec bash'")

print('This is a really long string' \
        'and it should be broken up')

web_lport = 8000

def start_webserver():
    url = f"localhost:{web_lport}"

    handler = http.server.SimpleHTTPRequestHandler
    httpd = socketserver.TCPServer(("", web_lport), handler)
    print(f"Web server starting on port {web_lport}")

    server_process = multiprocessing.Process(target=httpd.serve_forever)
    server_process.daemon = True
    server_process.start()

    return server_process

server_process = start_webserver()
# Do stuff
print(f"Closing web server running on port {web_lport}")
server_process.terminate()

if [[ "$(pgrep tmux)" ]]; then
  kill -9 `top -n 1 | pgrep tmux`
fi

tmux new -s web_server -d 'python -m SimpleHTTPServer'

sleep 1
python do_things.py

with open("test.txt", "a") as myfile:
    myfile.write("appended text")

s = """ this is a very
        long string if I had the
        energy to type more and more ..."""

headers = {
 'Host': host+':'+port,
 'Content-Length': '85',
 'Transfer\x09-Encoding': 'chunked',
}

data = '0\x0d\x0a\x0d\x0a' \
    'GET /' \
    '/ HTTP/1.1\x0d\x0aHost: ' + host + ':' + port'

s = requests.Session()
req = requests.Request("POST", protocol+'://'+host+':'+port,
                       headers=headers, data=data)
prepped = req.prepare()
prepped.headers['Content-Length'] = 85
s.send(prepped)

proxies = {"http": "http://127.0.0.1:8090", "https": "http://127.0.0.1:8090"}

response = requests.post(target_url, headers=headers, json=data, verify=False, timeout=15,
proxies=proxies)

python -c 'print "A" * 32'

python -c "print('b'*64)" | pbcopy

if not dict.has_key(key):
    dict[key] = [value]
else:
    dict[key].append(value)

dict = {}

dict[c] = 1

dict[c] += 1

from prettytable import PrettyTable
def output_dict_to_table(in_dict):
        """
        Print an input dictionary as a table

        Usage:
        output_dict_to_table({'Key': ['Value'], 'Key2': ['Value2', 'Value3']})
        """
        t = PrettyTable(['Key', 'Value'])
        for k, v in in_dict.items():
            t.add_row([k, v])
        print t

# Output is bytes; convert to string with the .decode('utf-8')
output = run_cmd('terraform output -json').decode('utf-8')
tf_json = json.loads(output)

['h','e','l','l','o']

{'l': 2, 'h': 1, 'e': 1, 'o': 1}

from collections import Counter
print(Counter(['h','e','l','l','o']))

from collections import Counter
print(Counter('hello'))

from collections import Counter
words = ['hi', 'bye', 'toodles']
word_to_chars = {}
for word in words:
    word_to_chars[word] = Counter(word)
print(word_to_chars)

# {'bye': Counter({'y': 1, 'b': 1, 'e': 1}), 'hi': Counter({'i': 1, 'h': 1}), 'toodles':
Counter({'o': 2, 'e': 1, 'd': 1, 'l': 1, 's': 1, 't': 1})}

def check_if_in_list_of_dict(sample_dict, value):
    """Check if given value exists in list of dictionaries """
    for elem in sample_dict:
        if value in elem.values():
            return True
    return False

if check_if_in_list_of_dict(dict_name, 'value'):
    print('yep')

# Open new tab
driver.execute_script("window.open('');")
# Switch to new tab
driver.switch_to.window(driver.window_handles[1])
# Load stackoverflow
driver.get("http://stackoverflow.com")
# Wait for page to load
time.sleep(3)
# Close the new tab
driver.close()

driver.switch_to.window(driver.window_handles[0])

driver.page_source

driver.get_cookies()

driver.get_cookie('cookie_name')['value']

from selenium import webdriver
from browsermobproxy import Server
import time

server = Server(
    path="./assets/browsermob-proxy-2.1.4/bin/browsermob-proxy", options={'port':
8095})
server.start()
proxy = server.create_proxy()

profile = webdriver.FirefoxProfile()
selenium_proxy = proxy.selenium_proxy()
profile.set_proxy(selenium_proxy)
driver = webdriver.Firefox(firefox_profile=profile)

proxy.new_har('req', options={'captureHeaders': True, 'captureContent': True})
driver.get("https://www.google.com")
print(proxy.har)

server.stop()
driver.quit()

driver.find_element_by_xpath('<copied xpath>').click()

import pandas as pd
table = pd.read_html(driver.page_source)
# Print all values associated with a particular column
df = table
print(df.<column_name>)
# for example:
# print(df.IP)

driver.find_element_by_xpath(
      "//*[contains(text(), 'text to match')]")

driver.find_element_by_xpath(
      "//button[normalize-space()='text to match']").click()

from selenium.webdriver.common.keys import Keys
driver.find_element_by_name('elementName').send_keys(Keys.BACK_SPACE)

from selenium.webdriver.support import expected_conditions as EC
# wait for 10 seconds for the page to load
delay = 10
try:
    WebDriverWait(driver, delay).until(
       EC.presence_of_element_located((By.ID, 'name of id associated with element
you want')))
except TimeoutException:
    sys.exit("Loading the page took too much time, exiting!")

import argparse

def parse_arg():
    parser = argparse.ArgumentParser(description='Do stuff')
    parser.add_argument("-a", '--argument', required=True, help='description of what
your awesome code does')
    return parser.parse_args()
    # Return value of a single argument if you don't have multiple ones:
    #return parser.parse_args().arg

import argparse

def __parse_args__():
    parser = argparse.ArgumentParser(
        description='Do stuff.')
    group = parser.add_mutually_exclusive_group(required=True)
    group.add_argument('-f', action=.....)
    group.add_argument('-d', type=bool, help='do a boolean thing')
    return parser.parse_args()

parser.add_argument('-d', dest="debug", action='store_true',
   help='debug mode')

import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex(('127.0.0.1',80))
if result == 0:
   print "Port is open"
else:
   print "Port is not open"
sock.close()

status_code = subprocess.call(
    ['ansible-playbook', 'site.yml', '-i', 'hosts'])
# status_code = 0 is an indicator of running the command successfully

import smtplib

from email.mime.text import MIMEText

smtp_user = 'youruser@yourdomain.com'
smtp_pw = 'YEP PUT THAT HERE'

sender = ['yoursender@domain.com']
recipients = ['person1@gmail.com', 'person2@gmail.com']

msg = MIMEText('Sweet text br0')
msg['Subject'] = "Awesome Subject
msg['From']    = ','.join(sender)
msg['To']      = ','.join(recipients)

s = smtplib.SMTP('smtp.mailgun.org', 587)

s.login(smtp_user, smtp_pw)
s.sendmail(sender, recipients, msg.as_string())
s.quit()

import smtplib

from email.mime.text import MIMEText

smtp_user = 'youruser@yourdomain.com'
smtp_pw = 'YEP PUT THAT HERE'

sender = ['yoursender@domain.com']
recipient = ['person1@gmail.com']
cc_emails = ['person2@gmail.com', 'person3@gmail.com']

msg = MIMEText('Sweet text br0')
msg['Subject'] = "Awesome Subject
msg['From']    = ','.join(sender)
msg['To']      = ','.join(recipient)
msg['Cc']      = ','.join(cc_emails)

s = smtplib.SMTP('smtp.mailgun.org', 587)

s.login(smtp_user, smtp_pw)
s.sendmail(sender, recipient+cc_emails, msg.as_string())
s.quit()

git.Repo.clone_from(f"https://github.com/{self.user_name}/{self.repo_name}.git",
f"./{self.repo_name}")

os.environ['GIT_USERNAME'] = config.username
os.environ['GIT_PASSWORD'] = config.passwordrepo_path = 'repo_name'
try:
    repo = git.Repo(repo_path)
    repo.git.add(update=True)
    repo.index.commit('Commit Message')
    origin = repo.remote(name='origin')
    origin.push()
    print("Pushed the latest commit to the repo!")
except Exception as e:
    print(f"Failed to push the new commit due to {e}")
os.unsetenv('GIT_USERNAME')
os.unsetenv('GIT_PASSWORD')

from typing import Dict
import binascii
import hashlib
import hmac
import secrets
import string
import uuid

def gen_pw(size: str) -> str:
    return ''.join((secrets.choice(string.ascii_letters + string.digits + string.punctuation)
for i in range(size)))

def create_pw_hash(size: int) -> Dict[bytes, bytes]:
    """
    Hash the provided password with a randomly-generated salt and return the
    salt and hash to store in the database.
    """
    salt = secrets.token_bytes(32).hex().upper()
    password = gen_pw(size)
    key = hashlib.sha256(password.encode('utf-8') + salt.encode('utf-8'))
    return { 'salt': salt, 'key': key.hexdigest(), 'pw': password }

def is_correct_password(salt: str, pw_hash: str, password: str) -> bool:
    """
    Given a previously-stored salt and hash, and a password provided by a user
    trying to log in, check whether the password is correct.
    """
    return hmac.compare_digest(
        pw_hash,
        hashlib.sha256(password.encode('utf-8') + salt.encode('utf-8')).hexdigest()
    )

output = create_pw_hash(32)
assert(is_correct_password(output['salt'], output['key'], output['pw']))

strings_from_html = ' '.join(BeautifulSoup(html_code, "html.parser").stripped_strings)
words = strings_from_html.split()

from collections import Counter
stuff = {'bla':4,'hey':6,'chicken':2,'bob':10}
counter = Counter(stuff)
print(counter.most_common(3))

# Random string
a = '6f8FGlE(u'
str.encode(a)

# Random string
a = b'6f8FGlE(u'
a.decode('utf-8')

hex_string = '6465616462656566'
bytes.fromhex(hex_string)
# b'deadbeef'

byte_string = b"deadbeef"
byte_string.hex()
# '6465616462656566'

from bs4 import BeautifulSoup

soup = BeautifulSoup(input, 'html.parser')
for a in soup.find_all('a', href=True):
    if a.text:
        print(a['href'])

from pathlib import Path
home = str(Path.home())

from os.path import expanduser
home = expanduser("~")

import argparse
# Initialize parser
parser = argparse.ArgumentParser()
# Adding optional argument
parser.add_argument('--foo', type=str, help='foo help')
# Read arguments from command line
args = parser.parse_args()

print(args.foo)

import os
print(os.path.expanduser('~')

import shutil

# Source path
source = "/home/User/Documents/file.txt"

# Destination path
destination = "/home/User/Documents"

try:
    shutil.copyfile(source, destination)
    print("File copied successfully.")

# If source and destination are same
except shutil.SameFileError:
    print("Source and destination represents the same file.")

# If destination is a directory.
except IsADirectoryError:
    print("Destination is a directory.")

# If there is any permission issue
except PermissionError:
    print("Permission denied.")

# For other errors
except:
    print("Error occurred while copying file.")

import os

abspath = os.path.abspath(__file__)
dname = os.path.dirname(abspath)
os.chdir(dname)

import os, os.path

def safe_open_w(path):
    ''' Open "path" for writing, creating any parent directories as needed.
    '''
    os.makedirs(os.path.dirname(path), exist_ok=True)
    return open(path, 'w')

with safe_open_w('/Users/bill/output/output-text.txt') as f:
    f.write(...)

python3 -c 'import crypt; print(crypt.crypt("sickpasswordbro!", crypt.mksalt(crypt.METHOD_SHA512)))'