!pulptest

from scipy.optimize import linprog

from IPython.display import Image

for url in ("https://bit.ly/3a6qEkq", "https://bit.ly/3krYDsb"):
    display(Image(url=url))

obj = (
    -1,
    -2,
)
lhs_ineq = (
    (2, 1,),
    (-4, 5,),
    (1, -2),
)
rhs_ineq = (
    20,
    10,
    2,
)
lhs_eq = ((-1, 5,),)
rhs_eq = (15,)

(bnd := ((0, float("inf"),),) * 2)

(opt := linprog(
    c=obj,
    A_ub=lhs_ineq,
    b_ub=rhs_ineq,
    A_eq=lhs_eq,
    b_eq=rhs_eq,
    bounds=bnd,
    method="revised simplex",
))

opt.fun

opt.x

from jinja2 import Template
from faker import Faker

fake = Faker()

context = dict(items=[fake.catch_phrase() for _ in range(3)])
template = Template(
    """Example list in Jinja2
{%- for item in items %}
    - {{ item }}
{%- endfor %}
"""
)
print(template.render(**context))

template = Template(
    r"""Example list in Jinja2
\documentclass{{'{'}}article{{'}'}}
\begin{{'{'}}document{{'}'}}
  Hello World!
\begin{{'{'}}itemize{{'}'}}
{%- for item in items %}
    \item{{ item }}
{%- endfor %}
\end{{'{'}}itemize{{'}'}}
\end{{'{'}}document{{'}'}}
"""
)
print(template.render(**context))

(latex_translation := str.maketrans((original_latex := {"{": "«", "}": "»"})))

(reverse_latex_translation := str.maketrans(dict(zip(original_latex.values(), original_latex.keys()))))

(jina_translation := str.maketrans((original_jinja := {"≤": "{", "≥": "}", "|": "%",})))

(
    reverse_jinja_translation := str.maketrans(
        dict(zip(original_jinja.values(), original_jinja.keys()))
    )
)

print(
    r"""{%- for item in items %}
    \item{{ item }}
{%- endfor %}""".translate(
        reverse_jinja_translation
    )
)

print(
    latex_template := Template(
        r"""\documentclass{article}
\begin{document}
  Hello World!
\begin{itemize}
    ≤|- for item in items |≥
    \item ≤≤ item ≥≥
≤|- endfor |≥
\end{itemize}
\end{document}""".translate(
            latex_translation
        )
        .translate(jina_translation)
        .translate(reverse_latex_translation)
    ).render(**context)
)

import tempfile
import os

fd, name = tempfile.mkstemp()
with os.fdopen(fd, 'w') as fh:
    fh.write(latex_template)

!mc cp $name dokkuminio/public/simple_list.tex

!curl -s https://minio.apps.selfip.com/public/simple_list.tex | pdflatex -output-directory latex_templates/

!mc cp latex_templates/texput.pdf dokkuminio/public/

from IPython.display import display, IFrame

IFrame("https://minio.apps.selfip.com/public/texput.pdf", width=900, height=800)

import matplotlib.pyplot as plt

import numpy as np

np.random.seed(444)

fig, _ = plt.subplots()

type(one_tick := fig.axes[0].yaxis.get_major_ticks()[0])

fig, ax = plt.subplots()

type(ax)

(rng := np.arange(50))

(rnd := np.random.randint(0, 10, size=(3, rng.size)))

(yrs := 1950 + rng)

fig, ax = plt.subplots(figsize=(5, 3))

ax.stackplot(yrs, rng + rnd, labels=["Eastasia", "Eurasia", "Oceania"])

ax.set_title("Combined debt growth over time")

ax.legend(loc="upper left")

ax.set_ylabel("Total debt")

ax.set_xlim(xmin=yrs[0], xmax=yrs[-1])

fig.tight_layout()

fig

(x := np.random.randint(low=1, high=11, size=50))

(y := x + np.random.randint(1, 5, size=x.size))

(data := np.column_stack((x, y)))

fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(8, 4))

ax1.scatter(x=x, y=y, marker="o", c="r", edgecolor="b")

ax1.set_title("Scatter: $x$ versus $y$")

ax1.set_xlabel("$x$")

ax1.set_ylabel("$y$")

ax2.hist(data, bins=np.arange(data.min(), data.max()), label=("x", "y"))

ax2.legend(loc=(0.65, 0.8))

ax2.set_title("Frequencies of $x$ and $y$")

ax2.yaxis.tick_right()

fig

tuple(fig.axes[i] is ax for i, ax in zip(range(2), (ax1, ax2)))

fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(7, 7))

type(ax)

ax

ax1, ax2, ax3, ax4 = ax.flatten()

import tarfile
from urllib.request import urlretrieve
from pathlib import Path

filepath, response = urlretrieve(
    "http://www.dcc.fc.up.pt/~ltorgo/Regression/cal_housing.tgz"
)

filepath

with tarfile.open(name=filepath, mode="r") as archive:
    housing = np.loadtxt(
        archive.extractfile("CaliforniaHousing/cal_housing.data"), delimiter=","
    )

housing

(y := housing[:, -1])

pop, age = housing[:, [4, 7]].T

pop, age

def add_titlebox(ax, text):
    ax.text(
        0.55,
        0.8,
        text,
        horizontalalignment="center",
        transform=ax.transAxes,
        bbox=dict(facecolor="white", alpha=0.6),
        fontsize=12.5,
    )
    return ax

gridsize = (3, 2)
fig = plt.figure(figsize=(12, 8))
ax1 = plt.subplot2grid(gridsize, (0, 0), colspan=2, rowspan=2)
ax2 = plt.subplot2grid(gridsize, (2, 0))
ax3 = plt.subplot2grid(gridsize, (2, 1))

ax1.set_title("Home value as a function of home age & area population", fontsize=14)
sctr = ax1.scatter(x=age, y=pop, c=y, cmap="RdYlGn")
plt.colorbar(sctr, ax=ax1, format="$%d")
ax1.set_yscale("log")
ax2.hist(age, bins="auto")
ax3.hist(pop, bins="auto", log=True)
add_titlebox(ax2, "Histogram: home age")
add_titlebox(ax3, "Histogram: area population (log scl.)")

fig

[plt.figure(i) for i in plt.get_fignums()]

plt.get_fignums()

(x := np.diag(np.arange(2, 12))[::-1])

x[np.diag_indices_from(x[::-1])] = np.arange(2, 12)
x

(x2 := np.arange(x.size).reshape(x.shape))

sides = (
    "left",
    "right",
    "top",
    "bottom",
)

nolabels = {s: False for s in sides}

nolabels.update({f"label{s}": False for s in sides})

nolabels

from mpl_toolkits.axes_grid1.axes_divider import make_axes_locatable

with plt.rc_context(rc={"axes.grid": False}):
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4))
    ax1.matshow(x)
    img2 = ax2.matshow(x2, cmap="RdYlGn_r")
    for ax in (ax1, ax2):
        ax.tick_params(axis="both", which="both", **nolabels)
    for i, j in zip(*x.nonzero()):
        ax1.text(j, i, x[i, j], color="white", ha="center", va="center")
    divider = make_axes_locatable(ax2)
    cax = divider.append_axes("right", size="5%", pad=0)
    plt.colorbar(img2, cax=cax, ax=[ax1, ax2])
    fig.suptitle("Heatmaps with `Axes.matshow`", fontsize=16)

import pandas as pd

(s := pd.Series(np.arange(5), index=list("abcde")))

(ax := s.plot())

type(ax)

id(plt.gca()), id(ax)

import matplotlib.transforms as mtransforms

url = "https://fred.stlouisfed.org/graph/fredgraph.csv?id=VIXCLS"

vix = pd.read_csv(
    url, index_col=0, parse_dates=True, infer_datetime_format=True, squeeze=True
).dropna()

vix = vix[vix != "."]

(ma := vix.rolling("90d").mean())

{type(item) for item in vix}

vix_ = pd.Series([float(item) for item in vix])

state = pd.cut(ma, bins=[-np.inf, 14, 18, 24, np.inf], labels=range(4))
cmap = plt.get_cmap("RdYlGn_r")
ma.plot(color="black", linewidth=1.5, marker="", figsize=(8, 4), label="VIX 90d MA")
ax = plt.gca()  # Get the current Axes that ma.plot() references
ax.set_ylabel("90d moving average: CBOE VIX")
ax.set_title("Volatility Regime State")
ax.grid(False)
ax.legend(loc="upper center")
ax.set_xlim(xmin=ma.index[0], xmax=ma.index[-1])
trans = mtransforms.blended_transform_factory(ax.transData, ax.transAxes)
for i, color in enumerate(cmap([0.2, 0.4, 0.6, 0.8])):
    ax.fill_between(ma.index, 0, 1, where=state == i, facecolor=color, transform=trans)
ax.axhline(
    vix_.mean(),
    linestyle="dashed",
    color="xkcd:dark grey",
    alpha=0.6,
    label="Full-period mean",
    marker="",
)

import jwt

(encoded := jwt.encode({"some": "payload"}, "secret"))

jwt.decode(encoded, "secret", algorithms=["HS256"])

from datetime import datetime, timedelta
import time
import arrow

(
    encoded := jwt.encode(
        {"exp": (exp := datetime.utcnow() + timedelta(seconds=3))}, "secret"
    )
)

print(len(encoded))

time.sleep(4)  # Allow time to expire.

try:
    jwt.decode(encoded, "secret")
except jwt.ExpiredSignatureError:
    print(f"Signature expired {arrow.get(exp).humanize()}.")

from pathlib import Path
import urllib.request
from urllib import parse
import pickle
from string import digits
from functools import partial

from IPython.display import HTML, Image, Markdown

(df,) = (
    pickle.loads(Path(fp).read_bytes())
    for fp, _ in (
        urllib.request.urlretrieve(
            (Path.home() / ".texpander" / "iowa_sports_pk_url").read_text()
        ),
    )
)

display(df)

from chamelboots import ChameleonTemplate as CT
from chamelboots import TalStatement as TS
from chamelboots.constants import FAKE, JoinWith
from chamelboots.html.utils import prettify_html

TSCS, TSR, TSA = (
    TS(*args)
    for args in (
        ("content", f"structure content"),
        ("repeat", "content items"),
        ("attributes", "attributes"),
    )
)

LINK = CT("a", (TSCS, TSA)).render
SPAN = partial(
    CT("span", (TSCS, TSA)).render, attributes=dict(style="font-size: 2.5rem;")
)
SPAN(content="foo")

menu_items, anchors = zip(
    *(
        (
            LINK(
                content=f"{item.sex}' {item.sport}",
                attributes={
                    "href": f"#{(id_ := item.sport_id.strip(digits))}",
                    "id": (menu_id := f"menu-{id_}"),
                },
            ),
            LINK(
                content=SPAN(content="back to menu"),
                attributes={"id": id_, "href": f"#{menu_id}"},
            ),
        )
        for item in df.itertuples()
    )
)

list_items = prettify_html(
    CT("ul", (TSCS,)).render(content=CT("li", (TSR, TSCS)).render(items=menu_items))
)

print(JoinWith.LINES(list_items.splitlines()[:10]))

anchors[:5]

HTML(list_items)

from chamelboots.imageutils import get_scaled_screenshot

for anchor, item in zip(anchors, df.itertuples()):
    for item in (HTML(anchor), Image(filename=get_scaled_screenshot(item.url))):
        display(item)