Amjith Ramanujam

and

sqlite> \llm

sqlite> \llm models
OpenAI Chat: gpt-4o (aliases: 4o)
OpenAI Chat: gpt-4o-mini (aliases: 4o-mini)
OpenAI Chat: gpt-4 (aliases: 4, gpt4)
....
....
OpenAI Chat: o1
OpenAI Chat: o1-2024-12-17
OpenAI Chat: o1-preview
OpenAI Chat: o1-mini
Default: gpt-4o-mini

sqlite> \llm install llm-gemini
sqlite> \llm models
OpenAI Chat: gpt-4o-mini (aliases: 4o-mini)
OpenAI Chat: o1-mini
...
...
GeminiPro: gemini-pro
GeminiPro: gemini-1.5-pro-latest
...
...
GeminiPro: gemini-2.0-flash-thinking-exp-01-21
Default: gpt-4o-mini

$ ollama pull qwen2.5-coder

sqlite> \llm install llm-ollama
sqlite> \llm models
OpenAI Chat: gpt-4o-mini (aliases: 4o-mini)
OpenAI Chat: o1-mini
....
Ollama: deepseek-r1:latest (aliases: deepseek-r1)
Default: gpt-4o-mini

sqlite> \llm models default qwen2.5-coder

sqlite> \llm "Customer with highest sales in the last month"
sqlite> SELECT customer
        FROM sales
        WHERE datetime(timestamp / 1000000, 'unixepoch') >= datetime('now', '-1 month')
        ORDER BY amount DESC LIMIT 1;

 sqlite> \llm+ "Top 5 urls visited."
 To determine the "Top 5 URLs visited," the following tables are utilized:

 **`urls`**: This table contains the URL information along with the
   `visit_count`, which tracks how many times each URL has been visited.
   Using this table allows for an efficient retrieval of the most
   visited URLs without the need for complex aggregations.

 **SQL Query:**

 SELECT url, visit_count
 FROM urls
 ORDER BY visit_count DESC
 LIMIT 5;

 sqlite> SELECT url, visit_count
         FROM urls
         ORDER BY visit_count DESC
         LIMIT 5;

** This feature is ONLY enabled when it is used for the first time. **

uv tool install litecli@latest

$ litecli your_database_file.db

SQLite> \llm "Your Question Here"

SQLite> \llm "Top 5 most visited URLs"

$ llm keys set openai
Enter key: ...

$ llm models default
gpt-4o

import llm
from llm.cli import cli

MODELS = {x.model_id: None for x in llm.get_models()}

def build_command_tree(cmd):
    """Recursively build a command tree for a Click app.

    Args:
        cmd (click.Command or click.Group): The Click command/group to inspect.

    Returns:
        dict: A nested dictionary representing the command structure.
    """
    tree = {}
    if isinstance(cmd, click.Group):
        for name, subcmd in cmd.commands.items():
            if cmd.name == "models" and name == "default":
                tree[name] = MODELS  # List of available models
            else:
                # Recursively build the tree for subcommands
                tree[name] = build_command_tree(subcmd)
    else:
        # Leaf command with no subcommands
        tree = None
    return tree

# Generate the tree
COMMAND_TREE = build_command_tree(cli)

def get_completions(tokens, tree=COMMAND_TREE):
    """Get autocompletions for the current command tokens.

    Args:
        tree (dict): The command tree.
        tokens (list): List of tokens (command arguments).

    Returns:
        list: List of possible completions.
    """
    for token in tokens:
        if token.startswith("-"):
            # Skip options (flags)
            continue
        if tree and token in tree:
            tree = tree[token]
        else:
            # No completions available
            return []

    # Return possible completions (keys of the current tree level)
    return list(tree.keys()) if tree else []

if __name__ == "__main__":
    tokens = sys.argv[2:]  # Remove `llm` and pass in the rest of the args
    print(get_completions(tokens))

$ python autocomplete_llm.py llm models
['list', 'default']

$ python autocomplete_llm.py llm models default
['gpt-4o', 'gpt-4o-mini', 'gpt-4o-audio-preview', 'gpt-3.5-turbo', 'gpt-3.5-turbo-16k', 'gpt-4', 'gpt-4-32k', 'gpt-4-1106-preview', 'gpt-4-0125-preview', 'gpt-4-turbo-2024-04-09', 'gpt-4-turbo', 'o1-preview', 'o1-mini', 'gpt-3.5-turbo-instruct']

import os
import sys
import click

@click.command()
def cli():
    click.echo("CLI is running.")
    # Logic that determines when to restart
    if click.confirm("Do you want to restart the CLI?"):
        click.echo("Restarting CLI...")
        executable = sys.executable
        args = sys.argv
        os.execv(executable, [executable] + args)
    else:
        click.echo("Exiting CLI.")

if __name__ == '__main__':
    cli()

font-size = 17
font-family = Monaco
macos-option-as-alt = true  # Enables alt+f/alt+b keys to work as expected

ghostty +list-themes

Sempi: Did you know that Apollo actually shot a plague of arrows?
       But it is often misintepreted as he shot arrows of palgue.
Vian : What do you mean?
Sempi: He shot so many arrows in the sky that it was a plague of arrows.
       He did not shoot an arrow with plague in it.
Vian : Ooohhh. So he is not the god of plague?
Sempi: Exactly!
Vian : So he was a plauge of god.
Sempi: What? No! *Bah*

Vian : I think I'm ok at comedy.
Yoshi: Oh yeah!
Vian : Muhuhahaha! Muhuhahaha!

*Vian starts laughing maniacally*
*Yoshi joins in and start laughing*
*Vian stop abruptly while Yoshi is still laughing*

Vian : See, I told you I'm ok at comedy.

  Me: What is a pentagon? 
Vian: It's a polygon with five sides. 
  Me: Good! What is a regular pentagon? 
Vian: A regular pentagon? 
  Me: Yeah.
Vian: I think it is a pentagon that is not special? 
  Me: What?
Vian: It's a pentagon without anything special about it. Just regular.
  Me: *laughing* It's a pentagon with equal sides.
Vian: Oh!

Vian: Will you be available later today to answer some questions?

  Me: Sure, I'll be around. What questions do you have?

Vian: What was the best part of your day? Worst part of your day?
      things like that....

  Me: Dude, asking each other about our day is not an interrogation.

    Sempi: I'm going to have some tea before I get in the shower.

       Me: Hurry up you have 5 mins to finish your tea.

    Sempi: It'll take me more than 5 mins to just make the tea.

       Me: It's already 8 o' clock. I don't think you have time.

    Sempi: Ok. (Checks his watch)

       Me: (realizes he is precise) Technically it is 3 mins to 8. It is only 7:57.

    Sempi: No, it is 2 and a half minutes to 8, not 3.

Vian: How can we make sure we finish the levels before the timer runs out?
  Me: What if we go for different keys in parallel?
Vian: Oh yeah! I'll go for the silver key and you can go for the gold key?

   <silver key is usually harder>

  Me: Why? You don't trust me to get the silver key?
Vian: No. Usually the silver key is harder to get.
  Me: Right! You don't trust me to get it. You think I'm incompetent.
Vian: No. You're just bad.
  Me: Thanks for explaining it to me. Jackass.

SELECT count(*) FROM packages WHERE filename LIKE "nflx_%"

SELECT count(*) FROM packages WHERE filename LIKE "nflx\_%"

SELECT name, count(name) AS ct  FROM trails GROUP BY name ORDER BY ct DESC LIMIT 5

from sqlalchemy import func

def most_common_trails(db: Session):
    return (
        db.query(Trail)
        .group_by(Trail.name)
        .order_by(func.count(Trail.name).desc())
        .limit(5)
        .all()
    )

UPDATE users SET token = (SELECT token FROM users u WHERE u.id = 1) WHERE id = 2;

$ pip install 'torch<2' sentence-transformers

$ sqlite-utils convert posts.db posts title '
from sentence_transformers import SentenceTransformer
model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")

def convert(value):
    return model.encode(value).tobytes()
' \
    --output title_embeddings \
    --output-type blob

$ sqlite-utils convert posts.db posts mdbody '
from sentence_transformers import SentenceTransformer
model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")

def convert(value):
    return model.encode(value).tobytes()
' \
    --output body_embeddings \
    --output-type blob

$ litecli blog.db

sqlite> .load ./vector0
sqlite> .load ./vss0

sqlite> CREATE VIRTUAL TABLE posts_vss
        USING vss0(title_embedding(384), body_embedding(384))

sqlite> INSERT INTO posts_vss (rowid, title_embedding, body_embedding)
               SELECT rowid, title_embedding, body_embedding FROM posts

sqlite> CREATE TRIGGER posts_vss_ai AFTER INSERT ON posts 
          BEGIN 
               INSERT INTO posts_vss (rowid, title_embedding, body_embedding) 
               VALUES (new.rowid, new.title_embedding, new.body_embedding); 
          END;

# vector_search.py
from sentence_transformers import SentenceTransformer

model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
query = input("Enter search term: ")
query_embedding = model.encode(query).tolist()

# vector_search.py
import sqlite3
import sqlite_vss
from sentence_transformers import SentenceTransformer

model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
query = input("Enter search term: ")
query_embedding = model.encode(query).tolist()

db = sqlite3.connect("blog.db")
db.enable_load_extension(True)
sqlite_vss.load(db)

stmt = f"""
with body_matches as (
        select rowid from posts_vss where vss_search(body_embedding, '{query_embedding}')
        limit 5
        ),
    title_matches as (
        select rowid from posts_vss where vss_search(title_embedding, '{query_embedding}')
        limit 5
        )
select distinct posts.id, posts.url, posts.title 
    from body_matches, title_matches 
    left join posts on posts.rowid = body_matches.rowid or posts.rowid = title_matches.rowid
"""
results = db.execute(stmt)
print(list(results))

$ python vector_search.py
Enter search term: lemon
[
 (134, 'http://blog.amjith.com/the-lemonade-stand', 'The Lemonade Stand'), 
 (116, 'http://blog.amjith.com/orange-juice-with-p-star-star-p', 'Orange Juice with p**p'), 
 (190, 'https://blog.amjith.com/orange', 'Orange?'), 
 (35, 'http://blog.amjith.com/shenanigans', 'Shenanigans'), 
 (118, 'http://blog.amjith.com/chocolate-juice', 'Chocolate Juice'), 
 (49, 'http://blog.amjith.com/conversations-with-a-4-year-old', 'Conversations with a 4 year old'), 
 (158, 'http://blog.amjith.com/dinner-and-bsg', 'Dinner and BSG')
]

datasette install datasette-sqlite-vss

# vector_encode.py
import json
from datasette import hookimpl
from sentence_transformers import SentenceTransformer
model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")

@hookimpl
def prepare_connection(conn):
    conn.create_function("vector_encode", 1, vector_encode)

def vector_encode(term):
    embeddings = model.encode(term)
    return json.dumps(embeddings.tolist())

datasette blog.db --plugins=plugins/

with body_matches as (
        select rowid from posts_vss where vss_search(body_embedding, vector_encode(:term))
        limit 5
        ),
    title_matches as (
        select rowid from posts_vss where vss_search(title_embedding, vector_encode(:term))
        limit 5
        )
select distinct posts.id, posts.url, posts.title from body_matches, title_matches 
    left join posts on posts.rowid = body_matches.rowid 
    or posts.rowid = title_matches.rowid

databases:
  blog:
    queries:
      vector_search:
        sql: |-
          with body_matches as (
                  select rowid from posts_vss where vss_search(body_embedding, vector_encode(:term))
                  limit 5
                  ),
              title_matches as (
                  select rowid from posts_vss where vss_search(title_embedding, vector_encode(:term))
                  limit 5
                  )
          select distinct posts.id, posts.url, posts.title from body_matches, title_matches left join posts on posts.rowid = body_matches.rowid or posts.rowid = title_matches.rowid          
        title: Vector Search

datasette blog.db --metadata=metadata.yml --plugins=plugins/

datasette publish fly blog.db --plugins-dir=plugins/ --metadata=metadata.yml \
                              --app=blog-vector-search \
                              --install=datasette-sqlite-vss \
                              --install="'torch<2'" \
                              --install=sentence-transformers

# sqlite-utils enable-fts <dbname> <tablename> <columns> --create-triggers
sqlite-utils enable-fts blog.db posts title mdbody --create-triggers

sqlite-utils search blog.db posts "lemon*" --limit 5

sqlite-utils search blog.db posts "lemon*" --limit 5 -c url  -c title --table

datasette serve blog.db

<html>
  <head>
    <script src="https://unpkg.com/htmx.org@1.9.2" integrity="sha384-L6OqL9pRWyyFU3+/bjdSri+iIphTN/bvYyM37tICVyOJkWZLpP2vGn6VUEXgzg6h" crossorigin="anonymous"></script>
  </head>
  <body>
    <input id="input-box" type="text" placeholder="Enter your input and press Enter" name="name">
    <div hx-get="/api/call1" hx-trigger="keyup delay:200ms from:#input-box">

    </div>
    <div hx-get="/api/call2" hx-trigger="keyup delay:200ms from:#input-box">

    </div>
    <div hx-get="/api/call3" hx-trigger="keyup delay:200ms from:#input-box">

    </div>
  </body>
</html>

import json
from sqlite_utils import Database   # pip install sqlite-utils
import runez                        # pip install runez

archives = ["https://blog.amjith.com/archive", "https://blog.amjith.com/archive?page=2"]
blog_urls = []
archive_js = """new Promise(done => setInterval(() => {done(
                    Array.from(
                      document.querySelectorAll(".archive-list ul li a")).map(x => x.href))
                   }, 1000));"""
# iterate over each archive page and grab the url for the individual posts
for archive_page in archives:
    r = runez.run("shot-scraper", "javascript", archive_page, archive_js)
    urls = json.loads(r.output)
    blog_urls.extend(urls)

post_js = """new Promise(done => setInterval(() => {
                    done({
                        title: document.querySelector(".post-title h2").innerText,
                        rawbody: document.querySelector(".post-body").innerHTML,
                        date: document.querySelector(".posthaven-formatted-date").getAttribute("data-unix-time"),
                        tags: Array.from(document.querySelectorAll("header .tags a")).map(x => x.innerText),
                        }
                        )
                   }, 5));"""
blog_posts = []
# iterate over each blog_url and fetch the title, post, tags and date
for url in blog_urls:
    print("Fetching", url)
    r = runez.run("shot-scraper", "javascript", url, post_js)
    content = json.loads(r.output)
    content["url"] = url
    blog_posts.append(content)

db = Database("blog.db")
db["posts"].insert_all(blog_posts, pk="id")

import sqlite_utils
from datetime import datetime
import os
from markdownify import markdownify as md  # pip install markdownify

db = sqlite_utils.Database("blog.db")
for row in db["posts"].rows:
    ts = datetime.fromtimestamp(int(row["date"]))
    # Convert ts to iso 8601
    slug = row["url"].rsplit("/", 1)[-1]
    date = ts.isoformat()
    year = ts.strftime("%Y")
    os.makedirs(year, exist_ok=True)
    filename = f"{year}/{slug}.md"
    with open(filename, "w") as f:
        f.write("---\n")
        f.write(f'title: "{row["title"]}"\n')
        f.write(f"date: {date}\n")
        f.write(f"tags: {row['tags']}\n")
        f.write(f'url: "/blog/{slug}"\n')
        f.write("---\n\n")
        f.write(md(row["rawbody"]))

# lcm.py - ver1 
    def lcm(arg1, arg2):
        i = max(arg1, arg2)
        while i < (arg1 * arg2):
            if i % min(arg1,arg2) == 0:
                return i
            i += max(arg1,arg2)
        return(arg1 * arg2)

    lcm(21498497, 3890120)

$ python -m cProfile lcm.py 
     7780242 function calls in 4.474 seconds

    Ordered by: standard name

    ncalls  tottime  percall  cumtime  percall filename:lineno(function)
         1    0.000    0.000    4.474    4.474 lcm.py:3()
         1    2.713    2.713    4.474    4.474 lcm.py:3(lcm)
   3890120    0.881    0.000    0.881    0.000 {max}
         1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
   3890119    0.880    0.000    0.880    0.000 {min}

$ python -m cProfile -o shorten.prof shorten.py   # saves the output to shorten.prof

$ ls
shorten.py shorten.prof

$ python 
>>> import pstats
>>> p  = pstats.Stats('script.prof')   # Load the profiler output
>>> p.sort_stats('calls')              # Sort the results by the ncalls column
>>> p.print_stats(5)                   # Print top 5 items

    95665 function calls (93215 primitive calls) in 2.371 seconds

   Ordered by: call count
   List reduced from 1919 to 5 due to restriction <5>

       ncalls  tottime  percall  cumtime  percall filename:lineno(function)
    10819/10539    0.002    0.000    0.002    0.000 {len}
           9432    0.002    0.000    0.002    0.000 {method 'append' of 'list' objects}
           6061    0.003    0.000    0.003    0.000 {isinstance}
           3092    0.004    0.000    0.005    0.000 /lib/python2.7/sre_parse.py:182(__next)
           2617    0.001    0.000    0.001    0.000 {method 'endswith' of 'str' objects}

$ pip install SquareMap RunSnakeRun
$ runsnake shorten.prof     #load the profile using GUI

def fibonacci(num):
        print 'fibonacci(%d)'%num
        if num in (0,1):
            return num
        return fibonacci(num-1) + fibonacci(num-2)>>> math\_funcs.fibonacci(4) # 9 function calls
 fibonacci(4)
 fibonacci(3)
 fibonacci(2)
 fibonacci(1)
 fibonacci(0)
 fibonacci(1)
 fibonacci(2)
 fibonacci(1)
 fibonacci(0)
 3

import memoized
@memoized
def fibonacci(num):
    print 'fibonacci(%d)'%num
    if num in (0,1):
        return num
    return fibonacci(num-1) + fibonacci(num-2)

>>> math_funcs.mfibonacci(4)  # 5 function calls
    fibonacci(4)
    fibonacci(3)
    fibonacci(2)
    fibonacci(1)
    fibonacci(0)
    3

def combo(w, l):
        lst = []
        if l < 1:
            return lst
        for i in range(len(w)):
            if l == 1:
                lst.append(w[i])
            for c in combo(w[i+1:], l-1):
                lst.append(w[i] + c)
        return lst

>>> combinations.combo('abcde',3)
    ['abc', 'abd', 'abe', 'acd', 'ace', 'ade', 'bcd', 'bce', 'bde', 'cde']

def max\_val(a,b):
    return a if a >b else b

[1, 'abc', [1,2,3]]

class newDataType
{
    int i;
    String str;
    Vector vInts;
};

>>> lst = [1,2,3]    # Create a list
>>> res = 2 in lst   # Check if 2 is in 'lst'
True

list lst;
lst.push_back(3);
lst.push_back(1);
lst.push_back(7);
list::iterator result = find(lst.begin(), lst.end(), 7); 
bool res = (result != lst.end())

>>> dir([])
['\_\_add\_\_', '\_\_class\_\_', '\_\_contains\_\_', '\_\_delattr\_\_', '\_\_delitem\_\_',
'\_\_delslice\_\_', '\_\_doc\_\_', '\_\_eq\_\_', '\_\_format\_\_', '\_\_ge\_\_', 
'\_\_getattribute\_\_', '\_\_getitem\_\_', '\_\_getslice\_\_', '\_\_gt\_\_', '\_\_hash\_\_',
'\_\_iadd\_\_', '\_\_imul\_\_', '\_\_init\_\_', '\_\_iter\_\_', '\_\_le\_\_', '\_\_len\_\_',
'\_\_lt\_\_', '\_\_mul\_\_', '\_\_ne\_\_', '\_\_new\_\_', '\_\_reduce\_\_', '\_\_reduce\_ex\_\_',
'\_\_repr\_\_', '\_\_reversed\_\_', '\_\_rmul\_\_', '\_\_setattr\_\_', '\_\_setitem\_\_',
'\_\_setslice\_\_', '\_\_sizeof\_\_', '\_\_str\_\_', '\_\_subclasshook\_\_', 'append',
'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

>>> help([].sort)
Help on built-in function sort:

sort(...)
    L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
    cmp(x, y) -> -1, 0, 1

selectp -t 0              # Select pane 0
splitw -h -p 50 'bpython' # Split pane 0 vertically by 50%
selectp -t 1              # Select pane 1
splitw -v -p 25           # Split pane 1 horizontally by 25%
selectp -t 0              # Select pane 0

bind P source-file ~/.tmux/pdev

wget -r -A.ppt http://www.stanford.edu/class/cs221/notes/ 

find -depth -type d -empty -exec rmdir {} \;

User Input: 0, 1, 5, 7-10
Output: 0,1,5,7,8,9,10

###### PrintParser.py #######

    #!/usr/bin/env python

    def convert(inp):
        """
 \* Get the input from user.
 \* Parse the input to extract numbers
 \*\* Split by comma
 \*\*\* Each item in the list will then be split by '-'
 \*\*\*\* Populate the number between a-b using range(a,b)

 >>> convert("")
 []
 >>> convert("1")
 [1]
 >>> convert("1,2")
 [1, 2]
 >>> convert("1,2-5")
 [1, 2, 3, 4, 5]
 >>> convert("1-3,2-5,8,10,15-20")
 [1, 2, 3, 2, 3, 4, 5, 8, 10, 15, 16, 17, 18, 19, 20]
 """
        if not inp:
            return []
        pages = []
        comma_separated = []
        comma_separated = inp.split(",")
        for item in comma_separated:
            if "-" in item:
                a = item.split("-")
                pages.extend(range(int(a[0]),int(a[1])+1))
            else:
                pages.append(int(item))

        return pages

    if __name__ == '\_\_main\_\_' :
        import doctest
        doctest.testmod()

$ egrep '^[A-Za-z]{4}$' /usr/share/dict/words

$ egrep '^[a-Z]{4}$' /usr/share/dict/word 


	#!/bin/bash

	dirty=`git status –porcelain -uno
	last_modified=`git show --pretty="format:" --name-only HEAD`

	if [ -n “$dirty” ]; then
	echo $dirty
	else
	echo $last_modified
	fi


	»> collection = [‘django_migrations.py’,
	‘django_admin_log.py’,
	‘main_generator.py’,
	‘migrations.py’,
	‘api_user.doc’,
	‘user_group.doc’,
	‘accounts.txt’,
	]


	»> import re # regex module from standard library.
	»> def fuzzyfinder(user_input, collection):
	suggestions = []
	pattern = ‘.'.join(user_input) # Converts ‘djm’ to ’d.j.*m’
	regex = re.compile(pattern) # Compiles a regex.
	for item in collection:
	match = regex.search(item) # Checks if the current item matches the regex.
	if match:
	suggestions.append(item)
	return suggestions

	»> print fuzzyfinder(‘djm’, collection)
	[‘django_migrations.py’, ‘django_admin_log.py’]

	»> print fuzzyfinder(‘mig’, collection)
	[‘django_migrations.py’, ‘django_admin_log.py’, ‘main_generator.py’, ‘migrations.py’]


	‘main_generator.py’ - 0
	‘migrations.py’ - 0
	‘django_migrations.py’ - 7
	‘django_admin_log.py’ - 9


	»> import re # regex module from standard library.
	»> def fuzzyfinder(user_input, collection):
	suggestions = []
	pattern = ‘.'.join(user_input) # Converts ‘djm’ to ’d.j.*m’
	regex = re.compile(pattern) # Compiles a regex.
	for item in collection:
	match = regex.search(item) # Checks if the current item matches the regex.
	if match:
	suggestions.append((match.start(), item))
	return [x for _, x in sorted(suggestions)]

	»> print fuzzyfinder(‘mig’, collection)
	[‘main_generator.py’, ‘migrations.py’, ‘django_migrations.py’, ‘django_admin_log.py’]


	regex = ‘(m.i.g)’

	‘main_generator.py’ -> ‘main_g’
	‘migrations.py’ -> ‘mig’
	‘django_migrations.py’ -> ‘mig’
	‘django_admin_log.py’ -> ‘min_log’


	»> print fuzzyfinder(‘user’, collection)
	[‘api_user.doc’, ‘user_group.doc’]


	[alias]
	open = !vim `git-open.sh`

Amjith Ramanujam

Mammoth Lakes Trip

Day 1: Canoeing and DnD

Day 2: Hiking, Ice cream and DnD

Day 3: Gondola and Bike Lesson

Day 4: Rest day

Day 5: Kayaking and Yoshi

Day 6: Mountain Biking

Day 7: Biking and Hiking

Day 8: Back Home

LLM in Litecli - 2

LLM in Litecli

Getting Started:

Auto-Completing Click Commands

Restart a Python CLI

Introducing LLMs to Litecli

Implementation Details

Inspiration

Goodbye Netflix

Ghostty Terminal

Gods and Plagues

Ok Comedian

Regular Pentagon

Nighttime Routine

Pedant

Honesty

Data Driven Decisions

Social engineered by my kids

My Room (essay by a 7yo)

LLMs and Freewill

Postgresql and Underscore

sqlite-utils + litecli

Python at Netflix

Finding the most frequent value in a SQLite column

Updating a SQLite row with a value from another row

Vector Search

Datasette

Search (FTS)

Triggering multiple api calls in HTMX

Migrating out of PostHaven

Opportunities

Opposite of a Crater

Egg Skin

Kinder Graduation

Conversations with a 6yo

Conversations about the largest number

Hot Cocoa Part 2

Measure of Age

Confidence of a 5yo

Bejeezus

Picture Day

Conversation with an 8yo

Conversations with an 8yo

Michelangelo

Musings of an 8 year old

Bug not a Feature

Not a Dinosaur

Nose Beard

Nevermind

Groovin'

Tricking a Couple of Kids

Computers and Memory

Orange?

Conversations with a 4yo

Joke by a 7yo

Strongest Family Member

!!con west

Treat Others How You Want To Be Treated

Elevenses

Creative Insult

Kids vs Adults

The Floss!

Examples are Awesome

Tattling

Monkey Bar

Captain Underpants - Potty Adventures - 2

Sorry!?

Potty Training Adventures - I

Conversations with a 2 yo

Punch Line