Python notes

def my_function(x: int, y: float) -> float:
    return x + y

assert 1 == 1
assert 1 == 1, "mathematics is a lie!"

my_dict = {"foo": 1, "bar": 'a'}

[f(x) for x in xs if p(x)]

def my_function(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

def http_error(status):
  match status:
      case 400:
          return "Bad request"
      case 404:
          return "Not found"
      case 418:
          return "I'm a teapot"
      case _:
          return "Something's wrong with the internet"

match point:
    case Point(x, y) if x == y:
        print(f"Y=X at {x}")
    case Point(x, y):
        print(f"Not on the diagonal")

for i in range(5):
    if i == 3:
        continue
    print(i)

from abc import ABC, abstractmethod

class Mammal:
    def __init__(self, name):
        self.name = name

class Flippable(ABC):
    @abstractmethod
    def doBackFlip(self):
        pass

class Person(Mammal, Flippable):
    def __init__(self, name):
        super().__init__(name)
        self.backpack = Backpack()

    def doBackFlip(self):
        print(f"{self.name} did a backflip!")

    def checkForApple(self):
        return self.backpack.checkForApple()

    def eatApple(self):
        if self.backpack.getApple():
            print(f"{self.name} ate an apple!")
        else:
            print(f"{self.name} has no apples to eat!")

class Backpack:
    def __init__(self):
        self.content = ['apple', 'sandwich']

    def checkForApple(self):
        return "apple" in self.content

    def getApple(self):
        if self.checkForApple():
            self.content.remove("apple")
            return "apple"
        return None

def main():
    john = Person("John")
    john.doBackFlip()
    if john.checkForApple():
        john.eatApple()
        john.eatApple()

if __name__ == "__main__":
    main()

from concurrent.futures import ThreadPoolExecutor
import subprocess

def run_commands_in_parallel(parameters, command_template, max_workers=4):
    """
    Executes a command in parallel over a set of parameters.

    Args:
    - parameters (List[Any]): A list of parameters to format the command with.
    - command_template (str): The command string template, expecting a single parameter for formatting.
    - max_workers (int, optional): The maximum number of concurrent workers. Defaults to 4.

    Raises:
    - subprocess.CalledProcessError: If a command fails to execute successfully.
    """
    def run_command(parameter):
        cmd = command_template.format(parameter)
        subprocess.run(cmd, shell=True, check=True)

    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        executor.map(run_command, parameters)

# Example usage
filenames = ["foobar1.xml", "foobar2.xml", "foobar3.xml"]
command = "<some/command/taking/a/file> {}"
run_commands_in_parallel(filenames, command)

import timeit
import pandas as pd
import plotnine as p9

def demo(n):
    return sum(range(n))

vals = [
    {"n": 2*k,
     "time": timeit.timeit(lambda: demo(10*k), number=100)}
    for k in range(1, 10000, 1000)]

df = pd.DataFrame(vals)

p = (p9.ggplot(df, p9.aes(x="n", y="time")) +
     p9.geom_point(size = 4) +
     p9.geom_smooth(method="lm") +
     p9.labs(x = "Size", y = "Time (s)") +
     p9.theme_bw())

p.save("foo.png")

import pickle

obj = {'foo': 'bar'}

with open('demo.pkl', 'wb') as f:
    pickle.dump(obj, f)

with open('demo.pkl', 'rb') as f:
    obj = pickle.load(f)

import json

with open('foo.json', 'r') as f:
    d = json.load(f)

with open('bar.json', 'w') as f:
    json.dump(d, f, indent=4)

conda env list

conda create -n myenv python=3.10

conda env remove -n myenv

conda activate myenv
conda deactivate

conda install -c bioconda -c conda-forge snakemake

conda env export > environment.yaml

conda env create -f environment.yaml

conda env update -n myenv -f environment.yml

f = h5py.File('mydataset.hdf5', 'a')
dset3 = f.create_dataset('subgroup2/dataset_three', (10,), dtype='i')
dataset_three = f['subgroup2/dataset_three']

import yaml

with open('config.yaml', 'r') as file:
    config = yaml.safe_load(file)

data = {
'name': 'Clark Evans',
'features': ['YAML']
}

with open('output.yaml', 'w') as file:
    yaml.dump(data, file)

import requests
from lxml import html

url = "https://doi.org/10.1371/journal.pcbi.1009805"
headers = {
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
    "Accept-Language": "en-GB,en;q=0.5",
    "User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:122.0) Gecko/20100101 Firefox/122.0",
}

response = requests.get(url, headers=headers)

if response.status_code == 200:
    tree = html.fromstring(response.content)
    xpath = "//ol[@class='references']"
    ordered_list = tree.xpath(xpath)

    if ordered_list:
        print(html.tostring(ordered_list[0], pretty_print=True).decode())
    else:
        print("Ordered list not found in the HTML.")
else:
    print(f"Failed to retrieve data: Status code {response.status_code}")

  # first train `my_cool_model'
torch.save(my_cool_model.state_dict(), "./demo.pt")
another_cool_model = CoolModel()
another_cool_model.load_state_dict(torch.load("./demo.pt"))

import unittest
import scipy.stats as stats
import numpy as np


class TestScipyStats(unittest.TestCase):

    def setUp(self):
        self.test_data = np.array([1, 2, 3, 4, 5])

    def test_mean(self):
        # use assertAlmostEqual to check 7 (default) decimal places
        self.assertAlmostEqual(np.mean(self.test_data), 3.0, 7)

    def test_min_max(self):
        self.assertEqual(np.min(self.test_data), 1)
        self.assertEqual(np.max(self.test_data), 5)

    def test_bogus(self):
        with self.assertRaises(AttributeError):
            self.test_data.fake()


if __name__ == '__main__':
    unittest.main()

sales_melted = sales.melt(id_vars=['Year'],
                          value_vars=['product_a', 'product_b', 'product_c'],
                          var_name='Product',
                          value_name='Sales')

my_df.rename(columns={"old_name_1": "new_name_1",
                      "old_name_2": "new_name_2"})

pd.crosstab(df.discrete_a, df.discrete_b)

gapminder_not_2002 = gapminder[gapminder.year != 2002]

%matplotlib inline

import matplotlib.pyplot as plt