#!/usr/bin/env -S uv run --script
# /// script
# dependencies = ["typer"]
# ///
import typer


def main(name: str):
    print(f"Hello {name}")


if __name__ == "__main__":
    typer.run(main)

This is pretty neat for those scripts you need something more than shell or even just python standard lib. One use case that comes to mind is xbar scripts. The linked blogpost has more details on how it works if you are interested.

In one of my side projects I have a function that fetches a RSS feed and then stores the items from the feed in a database with sqlx. To use the question mark operator in that function with all the results it gets from different libraries I use a FetchError. The possible errors in the function is sqlx::Error, reqwest::Error and feed_rs::parser::ParseFeedError.

use std::{error::Error, fmt::Display};
use feed_rs::parser::ParseFeedError;

#[derive(Debug, Clone)]
pub struct FetchError {
    pub message: String,
}

impl Display for FetchError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.message)
    }
}

impl Error for FetchError {}

impl From<reqwest::Error> for FetchError {
    fn from(err: reqwest::Error) -> Self {
        FetchError { message: err.to_string() }
    }
}

impl From<sqlx::Error> for FetchError {
    fn from(err: sqlx::Error) -> Self {
        FetchError { message: err.to_string() }
    }
}

impl From<ParseFeedError> for FetchError {
    fn from(err: ParseFeedError) -> Self {
        FetchError { message: err.to_string() }
    }
}

Instead of

match optionalValue {
    Some(value) => println!(value)
    _ => ()
}

it is possible to do

if let Some(value) {
    println!(value)
}

import { useRouter } from "next/router";
import { useEffect } from "react";

export function useLongPollRefresh(wait: number = 5000) {
    const router = useRouter()

    useEffect(() => {
    const id = setInterval(() => {
      if (/^\d+$/.test(router.query.slug as string)) {
        router.replace(router.asPath);
      }
    }, wait);
    return () => clearInterval(id);
  }, [router]);
}

I use this technique in a few places were the user creates a new entity that triggers background jobs that adds more data to the entity. It makes the user action seem snappier and then without having to add new api endpoints to long poll the extra data will show up when it s ready.

locals {
  buckets = ["bucket-one", "bucket-two"]
}
resource "google_storage_bucket" "generic-buckets" {
  count         = length(local.buckets)
  name          = local.buckets[count.index]
  location      = "EU"
}

This will generate two buckets with these state labels in terraform:

• resource.google_storage_bucket.generic-buckets[0]
• resource.google_storage_bucket.generic-buckets[1]

The problem with this is that if bucket-one is no longer needed and we remove it from the list then terraform will destroy both buckets and recreate bucket-two. That problem will disappear if for_each is used instead of count.

locals {
  buckets = ["bucket-one", "bucket-two"]
}
resource "google_storage_bucket" "generic-buckets" {
  for_each      = { for i, k in toset(local.buckets) : k => i }
  name          = each.key
  location      = "EU"
}

The code above creates the same buckets, but the state labels will now be using the value as the index:

• resource.google_storage_bucket.generic-buckets[”bucket-one”]
• resource.google_storage_bucket.generic-buckets[”bucket-two”]

This makes it possible to both remove items from the list and reorder them without destroying and recreating the buckets that has not been removed from the list.

These bookmarklets will scroll 500px up and down and are nice to have when some page disables the scrolling for some reason. Typical example is when showing ad blocker warning modal.

Up: javascript:window.scrollTo(0, window.scrollY - 500); Down: javascript:window.scrollTo(0, window.scrollY + 500);

To use it with vim, prefix the nvim command with the environment variable.

NVIM_APPNAME=lazyvim nvim

This is super useful when testing out different premade configs, but it can also be useful when making changes to the config without disrupting the daily workflow by having two clones of your own config into ~/.config/nvim and ~/.config/nvim-test

PATH=/opt/homebrew/bin/:$PATH

Viml

set clipboard+=unnamedplus

Lua

vim.opt.clipboard = 'unnamedplus'

See :help clipboard for more.

:w | !pytest %

This will first write the file and then run tests on the current path.

From sudo --help the following is printed:

-K, --remove-timestamp        remove timestamp file completely
-k, --reset-timestamp         invalidate timestamp file

sudo -K

This will completely remove the timestamp of the current sudo session. Thus, it is not possible to use together with a command since the command will not be able to run before the timestamp is deleted.

sudo -k

This will invalidate the timestamp by changing it to the finish time of the last command. This means that it can both be used standalone sudo -k and with a command like sudo -k apt install sl.

def _publish_pubsub_event(topic: str, message: PubSubMessage) -> None:
    PubSubPublisher(settings.GCLOUD_PROJECT, topic).publish(message)


def publish_pubsub_event(topic: str, message: PubSubMessage) -> None:
    return _publish_pubsub_event(topic, message)

The publish_pubsub_event gets imported everywhere so to mock it we need to mock it in the context is being used, but the _publish_pubsub_event is not being used anywhere else than here so we can mock it in the context of this file.

In the module level conftest.py there is a fixture with autouse=True and it mocks the _publish_pubsub_event and returns the mock so that the fixture can be loaded explicitly to assert that the mock was called in the cases we want to verify the messages sent.

@pytest.fixture(autouse=True)
def mock_pubsub_publish(mocker: MockerFixture):
    return mocker.patch("app.pubsub._publish_pubsub_event")

bind + switch-client -l

tx() {
  if [ -z ${1+x} ]; then
    session=$(tmux list-sessions | fzf | awk '{print $1}' | sed 's/:$//' )
    tmux a -t $session
  else
    if tmux list-sessions | grep $1 2>&1 > /dev/null; then
      tmux a -t $1
    else
      tmux new -s $1
    fi
  fi
}

_tx() {
  sessions=$(tmux list-sessions 2>/dev/null)
  if [[ -z "$1" ]]; then
     echo $sessions | awk '{split($0,a,":"); print a[1]}'
  else
    echo $sessions | awk '{split($0,a,":"); print a[1]}' | grep --color=never $1
  fi
}

complete -C _tx tx

Other examples:

alias -s md=glow
alias -s html=open
alias -s txt=less
alias -s json=jq

Add the following under aliases in gitconfig:

recent = "!git branch --sort=-committerdate --format=\"%(committerdate:relative)%09%(refname:short)\" | fzf --ansi | awk 'BEGIN{FS=\"\t\"} {print $2}' | xargs git checkout"