mac01021

    val pattern = java.util.regex.Pattern.compile ("""(?xs) ("(.*?)"|) ; ("(.*?)"|) (?: \r?\n | \z ) """)
    val matcher = pattern.matcher (input)
    while (matcher.find) {
      val col1 = matcher.group (2)
      val col2 = matcher.group (4)
      // ...
    }

mac01021

        if 'bfg.routes.matchdict' in environ:
            matchdict = environ['bfg.routes.matchdict']
            path = matchdict.get('traverse', '/')
            subpath = matchdict.get('subpath', '')
            subpath = tuple(filter(None, subpath.split('/')))
        else:
            # this request did not match a Routes route
            subpath = ()
            try:
                path = environ['PATH_INFO'] or '/'

mac01021

package main

import "fmt"

func main() {
        a := "GATTACACACT"
	b := "GTCAAACCCCTA"
	fmt.Println(a, len(a), "\t", b, len(b))

mac01021

import pdb
import sqlalchemy as sa
from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

Base = declarative_base()
engine = sa.create_engine("sqlite:///:memory:", echo=True)

mac01021

records =\
        (session.query(LaborItem)
         .join(ServiceUnit, ServiceUnit.id == LaborItem.punch_unit_id)
         .filter(LaborItem.date <= days[-1])
         .filter(LaborItem.date >= days[0])
         .filter(*unit_filters(LaborItem.punch_unit_id))
         .filter(ServiceUnit.is_active_sql(days[-1]))# is this what we want for long date ranges?
         .options(sa.orm.joinedload('pay_type'))
         .options(sa.orm.joinedload('pay_type.versions'))
         .options(sa.orm.joinedload('punch_job'))

mac01021

func Daemonize() {
	go func() {
		fmt.Println("Daemonizing...")
		ch := make(chan os.Signal, 1)
		signal.Notify(ch, os.Signal(syscall.SIGHUP))
		for _ = range ch {
		}
	}()
}

mac01021

#from data:stack import *

def Box box(st Int, hgt Int, wdt Int)

def [st Int, hgt Int] .box [pos Int] Box { closed(st, hgt, pos - o:st) }

def area[box Box] Int { box:hgt * box:wdt }

def [a Box] > [b Box] Bool { area[a] > area[b] }

mac01021

def Part part(side Side, typ String, size Int)

def Side {
    left
    right
    none
}

def symmetrize[parts Array[Part]] Array[String] {
    let symmetric Array[String] = newArray[]

mac01021

def passwordFrom[template String] String {
    map[template, passChar].scrambled
}

def passChar[c Rune] Rune {
    if c = {
        'a': lowercase[rand[0, 26]]
        'A': uppercase[rand[0, 26]]
        '0': digits[rand[0, 10]]
        '.': punctation[rand[0, 14]]

mac01021

            FetchRequest req = new FetchRequestBuilder()
                    .clientId(clientId)
                    .addFetch(topic, partition, offset, fetchSize)
                    .minBytes(1)
                    .maxWait(250)
                    .build();
            FetchResponse resp = underlying.fetch(req);
            if(resp.hasError()) {
                int code =  resp.errorCode(topic, partition);
                if (code == 9) {