jonathanslenders

"""
Simple reactivity system for Python.
Not thread safe.
License: MIT
"""

from collections.abc import Callable
from dataclasses import dataclass
from typing import Generic, Protocol, TypeVar, final

jonathanslenders

# Instructions:
# 1. apt install ffmpeg
# 2. Install this file as:  /etc/systemd/system/babymonitor.service
# 3. Use `arecord -L` and adjust this file so that it reflects the right audio device (`-i` flag).
# 4. Change User/Group and/or make sure this user is part of the 'audio' group.
# 5. systemctl enable babymonitor
# 6. systemctl start babymonitor
[Unit]
Description=Baby monitor mp3 stream
After=network.target

jonathanslenders

from __future__ import annotations

import typing

from mypy.nodes import FuncDef
from mypy.plugin import ClassDefContext, Plugin

__all__ = ["NoInitForABCPlugin"]

jonathanslenders

# Example to make Python's `webbrowser` module work over SSH.

# 1. Run the following code on the host machine:

import asyncio, webbrowser

async def handler(reader, writer):
    data = await reader.read()
    url = data.decode()
    addr = writer.get_extra_info('peername')

jonathanslenders

# - Short snippet extracted from a commercial Cisco project, to justif
# adding a `str.splitlines(return_indexes=True)` feature to Python. -

async def _start_download_and_index(self) -> None:
        """
        Download the file content (as a binary stream), index the lines
        (keep the line index in memory), and store the file content
        locally on disk. This needs to be as efficient as possible.
        We're dealing with huge (>1GB) files, but users typically view
        only a small portion of the file.

jonathanslenders

"""
Output:

    re solution 8.718856811523438
    clever solution 3.7440919876098633
"""
from itertools import accumulate, chain
import re
import time

jonathanslenders

 * Super-optimized for small spaces - read how we shrank the memory                                                                                     │ Date: Tue May 31 22:09:56 2022 +0200
"""
Comparing the performance of a cache built using a `dict` and  `__missing__` with functools.cache
"""
import time
from typing import TypeVar, Callable, Dict
from functools import cache

_K = TypeVar("_K")
_V = TypeVar("_V")

jonathanslenders

"""
Comparing the performance of a cache built using a `dict` +  `__missing__` against lru_cache
"""
import time
from typing import TypeVar, Callable, Dict, Deque
from collections import deque
from functools import lru_cache

_K = TypeVar("_K")
_V = TypeVar("_V")

jonathanslenders

#!/usr/bin/env python
"""
A simple example of a calculator program.
This could be used as inspiration for a REPL.
"""
import asyncio
from typing import Tuple

from prompt_toolkit.application import Application, create_app_session
from prompt_toolkit.document import Document

jonathanslenders

class Leaf:
    def __init__(self, val):
        self.val = val

    def values(self):
        # Following two lines for debugging.
        # So that we can see how many stack frames there
        # are at the deepest level while traversing the tree.
        import traceback; traceback.print_stack()