jelmervdl

def expand(expr:str):
    if (match := re.search(r"\{(.+?)\}", expr)):
        prefix = expr[:match.start()]
        for val in match.group(1).split(','):
            for suffix in expand(expr[match.end():]):
                yield prefix + val + suffix
    else:
        yield expr

jelmervdl

import multiprocessing as mp
from functools import wraps
from typing import Callable, Iterable, ParamSpec, TypeVar, Union


class EndOfIter:
    """Signals end of the offloaded iterator"""

    exc: Optional[Exception]

jelmervdl

#!/usr/bin/env python3
from zipfile import ZipFile
from numpy.lib.format import read_magic, _read_array_header
import httpio
import csv
import sys

out = csv.DictWriter(sys.stdout, ['name', 'shape', 'dtype'], dialect='excel-tab')

with httpio.open(sys.argv[1]) as zfh:

jelmervdl

def print_cells(*rows, format:Callable[[Any],str]=repr,file=None) -> None:
    # Convert it all to text
    text_rows = [
        [format(cell) for cell in row]
        for row in rows
    ]
    
    # Calculate column width
    widths = [
        max(len(cell) for cell in column)

jelmervdl

#!/usr/bin/env python3
# Script that reads sentences scored with hardrules
# prints the 0's directly to stdout
# and passes the sentences with 1 to the subprocess bicleaner score
import sys
import subprocess
from threading import Thread
from queue import SimpleQueue
from itertools import chain

jelmervdl

#!/usr/bin/env python3
import sys
import os

from argparse import ArgumentParser
from contextlib import ExitStack
from email.utils import parsedate_to_datetime
from http.client import HTTPResponse
from shutil import copyfileobj
from tempfile import TemporaryFile

jelmervdl

Language models are not computers. I'd say, they're terrible at reasoning because they can't follow simple instructions correctly. If it can't do this, then why should it be able to do its own logical reasoning?

Jelmer:

Are there more ones or more zeros in the following sequence: 1111111100000111111110000000000

ChatGPT:

To determine whether there are more ones or zeros in the sequence "1111111100000111111110000000000", we can simply count the number of ones and zeros in the sequence and compare them.

Counting the number of ones in the sequence, we get:

jelmervdl

#!/bin/bash
set -euo pipefail

scontrol show job $1 |
grep -oP '(?<=StdErr=).*' |
xargs less -SN

jelmervdl

class ReadWriteLock:
    def __init__(self):
        self.readers = 0
        self.lock = threading.Condition(threading.Lock())

    @contextmanager
    def lock_for_reading(self):
        self.lock.acquire()
        try:
            self.readers += 1

jelmervdl

const joinA = (strs) => [...strs.slice(0,-1), `and ${strs[strs.length-1]}`].join(', ');
const joinB = (strs) => `${strs.slice(0,-1).join(', ')} and ${strs[strs.length-1]}`;

const strs = new Array(10).fill().map((_, i) => (i + 1).toString());
console.log(joinA(strs))
console.log(joinB(strs))