unthingable

from abc import abstractmethod
from itertools import chain, imap

from typing import Any, Iterable
from typing import Callable, Generic, List
from typing import TypeVar

A = TypeVar('A')
B = TypeVar('B')
C = TypeVar('C')

unthingable

object lisMessages {

  case class PayloadData(name: String, newValue: JsValue, oldValue: JsValue)

  case class LisPayloadA[C:Format, D:Format] (
    uuid      : String,
    timestamp : String,
    source    : String,
    context   : C,
    model     : String,

unthingable

import Window
import Mouse
import Graphics.Input (Input, input, clickable)
import Dict

-- UTIL

enumerate : [a] -> [(Int, a)]
enumerate l = zip [1..length l] l

unthingable

(defn split-seq [s]
  "Extract a tail of all same elements: [1 1 0 0 0] -> [[1 1] [0 0 0]]"
  (let [l (last s)]
    (split-with #(not= l %) s)))

(defn recombine
  "Distribute tail: [[1] [1] [1] [0] [0]] -> [[1 0] [1 0] [1]]"
  ([a b] [a b])
  ([a b c] [a b c])
  ([a b c & more]

unthingable

from atom.api import Atom, Int

# This is not OK:
class A(Atom):
    x = Int()
    y = 0
    
    def f(self):
        self.y = 1  # not OK
        self.z = 5  # very not OK!

unthingable

;; (set-face-background hl-line-face "medium purple")
;; fix hl-line color dynamically:
(require 'hexrgb)
(defun my-fix-hl-line-color ()
  "Adjust hl-line color relative to current color theme"
  (interactive)
  (let*
      ((color (face-attribute 'default :background))
       (value (hexrgb-value color))
       (threshold 0.32)

unthingable

{
    "mytemplate": {
        "mappings": {
            "_default_": {
                "_all": {
                    "enabled": false
                },
                "_ttl": {
                    "default": "1d",
                    "enabled": true

unthingable

{
  "foobar" : {
    "pwpage" : {
      "dynamic_templates" : [ {
        "string_template" : {
          "mapping" : {
            "index" : "not_analyzed",
            "type" : "string"
          },
          "match" : "*",

unthingable

Stamped = namedtuple('Stamped', 'stamp obj')

cache = {}


def cached(ttl, func, *args, **kw):
    'Simple inline cache for function calls'
    key = (func.__name__,) + args

    entry = cache.get(key, None)

unthingable

AbstractBase(models.Model):
    foo = somefield

class Base(AbstractBase):
    c1 = models.OneToOneField('C1', null=True, blank=True)
    c2 = models.OneToOneField('C2', null=True, blank=True)
 
    def c(self):
       #only one additional query to get the base
        if self.c1_id: