goopi

$ # install QCacheGrind (KCacheGrind)
$ brew install qcachegrind
$ brew install graphviz
$ brew linkapps

$ pip install django-extensions

$ # run profiling server
$ ./manage.py runprofileserver 0:3000 --kcachegrind --prof-path=path/to/profiles

michaelfeathers

stems = ARGF.read
            .split
            .each_cons(2)
            .group_by { |word_pair| word_pair[0] }

def next_word ary
  ary[rand(ary.length).to_i][1]
end

e = Enumerator.new do |e|

noahlt

Python’s lru_cache is sensitive to order of keyword arguments

In case you were wondering, Python’s built-in LRU cache function decorator doesn’t cache function calls with the same keyword arguments written in a different order. That is, if you cache a function and then call it twice, with the same keyword arguments but written in a different order, on the second call you won’t get the cached result and the function will be re-run.

proof/example

Let’s construct an example. We’re interested in keyword arguments, so we’ll make our function only take keyword arguments (1). We want some side-effect to tell us whether it was a cache hit or miss, so we’ll print each keyword when we iterate over it (2). We want to cache a result, so we’ll return the sum of the values of the keyword arguments (3). Finally, we apply the lru_cache decorator to the function with a maxsize=None to let the cache grow unbounded. Putting all that together, we get:

thomasfinch

#!/bin/bash

# Before running this script:
# Find AC_CHECK_FILES([/proc/self/stat]) in configure.ac and comment it out
# cd into the fish source directory

FLAGS="-stdlib=libc++ -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk -target armv7-apple-darwin16 -miphoneos-version-min=8.0.0"
PREFIX=$(pwd)"/deb"

# Build fish

pirate

"""Run some code after the response is returned to the user in django
Great for analytics or other slow tasks that you don't want to block the response
to the user for.
"""

class HttpResponseWithCallback(HttpResponse):
    def __init__(self, *args, **kwargs):
        self.callback = kwargs.pop('callback')
        super().__init__(*args, **kwargs)

pirate

import sys

def current_function_name(above=1):
    """returns the calling function's __module__.__name__"""
    # https://gist.github.com/JettJones/c236494013f22723c1822126df944b12#gistcomment-2962311

    frame = sys._getframe()
    for frame_idx in range(0, above):
        frame = frame.f_back

mwhite

"""
Outputs history with bash and git aliases expanded.
"""
from __future__ import print_function

import re
from subprocess import check_output

BASH_ALIASES = {}
for line in check_output('bash -i -c "alias -p"', shell=True).split('\n'):

nysean79

#!/usr/bin/env bash
## Version 1.0.2

my_email_body="Test from telnet"
mail_server_ip="127.0.0.1"
mail_server_port="25"
recipient="sryan@example.com"
sender="\"Ubuntu Server\"<ubuntu@example.com>"

nc ${mail_server_ip} ${mail_server_port} << EOF

pirate

#!/usr/bin/env fish
# Script to store and retrieve config/secret key=value pairs in Cloudflare DNS records
# Encrypts secrets with a specified passphrase + salt using AES-256-CBC
#
# Usage:
# 
#  $ set_config some_config_key "example config value abc"
#  $ get_config some_config_key
#  example config value abc
# 

pirate

#!/usr/bin/env python3
# Get all the information you could ever want about the STDIN, STDOUT, STDERR file descriptors (e.g. is it a TTY, terminal, pipe, redirection, etc.)
# Works cross-platform on Windows, macOS, Linux, in Docker, and in Docker-Compose by using stat library
#
# Useful for detecting and handling different stdin/stdout redirect scenarios in CLI scripts,
#     e.g. is the user piping a file in or are they interactively typing things in?
#          is the process output being saved to a file or being printed to a terminal?
#          can we ask the user for input or is it a non-interactive masquerading as a TTY?
#
# Further reading: