Today I Learned

appendChild

Sun, 23 Feb 2025 01:05:06 GMT

Move an element from its current position to the new position. Also can be used across different containers.

const container = document.querySelector(".container");
container.appendChild(container.firstElementChild);

// carousel effect
setInterval(() => {
    const container = document.querySelector('.container');
    container.appendChild(container.firstElementChild);
  }, 1000)

Extract files from a docker container without running it

Fri, 24 Jan 2025 21:04:04 GMT

import docker
from docker.errors import APIError
from pathlib import Path
import tarfile

def pull_and_extract_files(image_url, output_directory):
    """
    Pulls a Docker image from a registry URL, extracts files from the /Nexus/CEI folder,
    and saves them to a specified directory on the disk.

    :param image_url: URL of the Docker image (e.g., "registry_url/repository:tag")
    :param output_directory: Directory where the files will be saved
    """
    client = docker.from_env()

    try:
        # Pull the image from the registry
        print(f"Pulling image {image_url}...")
        image = client.images.pull(image_url)
        print("Image pulled successfully.")

        # Create a temporary container from the image
        print("Creating temporary container...")
        container = client.containers.create(image.id)

        try:
            # Copy the /Nexus/CEI folder from the container
            print("Copying files from /Nexus/CEI...")
            tar_stream, _ = container.get_archive("/Nexus/CEI")

            # Ensure the output directory exists
            output_path = Path(output_directory)
            output_path.mkdir(parents=True, exist_ok=True)

            # Save the tar archive
            tar_file_path = output_path / "cei_files.tar"

            with tar_file_path.open("wb") as tar_file:
                for chunk in tar_stream:
                    tar_file.write(chunk)

            print(f"Files saved as tar archive: {tar_file_path}")
            print("Extracting tar archive...")

            # Extract the tar archive
            with tarfile.open(tar_file_path) as tar:
                tar.extractall(path=output_path)

            print(f"Files extracted to: {output_path}")

        finally:
            # Clean up the container
            print("Removing temporary container...")
            container.remove()

    except APIError as e:
        print(f"Docker API error: {e}")
    except FileNotFoundError as e:
        print(f"File not found: {e}")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")
    finally:
        client.close()

# Example usage
if __name__ == "__main__":
    image_url = "your_registry_url/your_repository:your_tag"
    output_dir = "/path/to/output_directory"
    pull_and_extract_files(image_url, output_dir)

Verify and lazy load imports of a python package

Fri, 24 Jan 2025 20:46:49 GMT

Scenario: You have a python package with an entry point class that needs to be instantiated and setup before other classes in the package can be imported and used.

Solution: Intercept the getattr method of the package's __init__.py file to verify and lazy load the other classes in the package.

__init__.py

# serverless

# Import entry point class
from .adr import ADR

# Expose entry point class
__all__ = ["ADR"]


# Lazy import mechanism for dependent classes
class _LazyLoader:
    """
    Lazy loader for dependent classes to defer imports until accessed.
    This enforces ADR.setup() to be called before triggering the imports.
    """

    def __init__(self):
        self._initialized = False

    def _initialize(self):
        """Perform the actual imports when accessed for the first time."""
        # Ensure ADR has been set up
        ADR.ensure_setup()

        # Define the modules to be imported
        item_classes = (
            "Item",
            "HTML",
            "Animation",
            ...
        )
        # Dynamically import classes from item and template using importlib
        import importlib

        item_module = importlib.import_module(".item", package=__package__)

        # Dynamically add these to the module namespace and __all__
        for cls_name in item_classes:
            cls = getattr(item_module, cls_name, None)
            if cls:
                globals()[cls_name] = cls
                __all__.append(cls_name)

        self._initialized = True

    def __getattr__(self, name):
        if not self._initialized:
            self._initialize()
        return globals()[name]


# Create a lazy loader instance
_lazy_loader = _LazyLoader()


# Define a custom module-level __getattr__ to defer imports
def __getattr__(name):
    return getattr(_lazy_loader, name)

adr.py

class ADR:
    # Class-level variable to track the active instance
    _curr_instance = None

    def __init__(
        self,
        ...
    ) -> None:
        ...
        self.is_setup = False
        ADR._curr_instance = self  # Set this as the current active instance

    def setup(self):
        """
        Perform the setup operations for the ADR instance.
        """
        ... # Perform setup operations
        self.is_setup = True

    @classmethod
    def ensure_setup(cls):
        """
        Check if the current ADR instance has been set up.
        Raise an ImportError if not.
        """
        if not cls._curr_instance or not cls._curr_instance.is_setup:
            raise ImportError(
                "ADR has not been set up yet. Please create an ADR instance and call its `setup()` method "
                "before importing and using other classes."
            )

Defining setup.py dependencies using a URL

Mon, 13 Jan 2025 17:46:13 GMT

Any branch on GitHub can be installed by pip by finding the URL to the zip export of that branch.

https://github.com/<owner>/<repository>/archive/refs/heads/<branch>.zip

The solution is to use packagename @ URL, like this:

setup(
    name="photos-to-sqlite",
    ...
    install_requires=[
        "sqlite-utils>=2.7",
        "boto3>=1.12.41",
        "osxphotos>=0.28.13 ; sys_platform=='darwin'",
    ]
    extras_require={
        "test": ["pytest", "black", "hypothesis", "cogapp"],
        "docs": [
            "furo",
            "sphinx-autobuild",
            "codespell",
            "sphinx-copybutton",
            "beanbag-docutils @ https://github.com/simonw/beanbag-docutils/archive/refs/heads/bytes-in-url.zip",
        ]
)

Efficiently copying a file

Mon, 13 Jan 2025 17:46:11 GMT

import shutil
shutil.copyfileobj(open('file1', 'rb'), open('file2', 'wb'))

https://docs.python.org/3/library/shutil.html#shutil.copyfileobj

Use setup.py to install platform-specific dependencies

Mon, 13 Jan 2025 16:52:03 GMT

setup(
    name="photos-to-sqlite",
    ...
    install_requires=[
        "sqlite-utils>=2.7",
        "boto3>=1.12.41",
        "osxphotos>=0.28.13 ; sys_platform=='darwin'",
    ]
)

So ; sys_platform=='darwin' in the install requires line.

More details: https://www.python.org/dev/peps/pep-0508/#environment-markers and https://hynek.me/articles/conditional-python-dependencies/

structuredClone

Mon, 13 Jan 2025 05:52:00 GMT

The object spread syntax ... makes a shallow clone of an object, but a shallow clone is only useful for cloning primitive values in the object. If you have values like arrays or objects, they aren’t cloned, but the reference to the original object is cloned. In late 2021, Deno, Node.js and Firefox released support for structuredClone, followed in 2022 by the other browsers. The structuredClone algorithm is a deep clone algorithm, like Python’s copy.deepcopy().

const mushrooms1 = {
  amanita: ["muscaria", "virosa"],
};

const mushrooms2 = structuredClone(mushrooms1);

mushrooms2.amanita.push("pantherina");
mushrooms1.amanita.pop();

console.log(mushrooms2.amanita); // ["muscaria", "virosa", "pantherina"]
console.log(mushrooms1.amanita); // ["muscaria"]

MDN docs

Update all submodules to latest commit on origin

Sat, 11 Jan 2025 23:37:22 GMT

I use Git submodules in a bunch of projects, and one common task is checking out the latest commit on the origin.

Since Git 1.8.2 this is a one-liner, but I'm always forgetting it, so here it is:

git submodule update --remote --rebase # or `--merge` if you swing that way

The answers to this StackOverflow question have some more detail (including a command that works on earlier versions of Git).

Ignore all .DS_Store files

Sat, 11 Jan 2025 23:37:22 GMT

If you use git on a Mac, chances are you've accidentally committed a .DS_Store to a repo. I used to reflexively add .DS_Store to all my .gitignore files to avoid ever repeating that mistake.

But there's a better way! You can add a global .gitignore file to your global config with this command:

git config --global core.excludesFile '~/.gitignore'

The single quotes around ~/.gitignore aren't strictly necessary; if you don't use them, the ~ will just get expanded into the absolute path to your home directory.

Under the hood, that command just adds this to your ~/.gitconfig:

[core]
        excludesFile = ~/.gitignore

Conditionally extend a template

Sat, 11 Jan 2025 23:37:22 GMT

Django supports template inheritance via the extends tag. Often, a template inheritance chain follows all the way up to a "base" template that contains the full markup for a page, from the doctype to the closing HTML tag.

A common pattern when using libraries like htmx is returning HTML fragments. In these cases, it can make sense to conditionally extend a template: return the full page when visited directly but return a fragment when requested via Ajax.

Let's say we have this page layout, layout.html:

<!DOCTYPE html>
<html>
  <head>
    <!-- ... -->
  </head>
  <body>
    {% block content %}{% endblock %}
  </body>
</html>

A template rendered within this layout would look something like this:

{% extends "layout.html"}

{% block content %}<p>Hello, world!</p>{% endblock %}

To render the template standalone, we can create a "stub" layout (say, ajax.html) that declares the block and nothing else:

{% block content %}{% endblock %}

Then, instead of using a string literal for the name of the template to extend, we use a variable. We can default to layout.html if it's omitted:

{% extends layout|default:"layout.html"}

{% block content %}<p>Hello, world!</p>{% endblock %}

The view that renders the template might look something like this:

def view(request: HttpRequest):
  return render(
    request,
    template_name="some_template.html",
    context={ "layout": "ajax.html" if request.headers.get("hx-request") else None },
  )