Skip to content

7th August 2024

Life Management

Time management

Org Mode

  • New: Change the default org-todo-keywords.

    orig = '''* NEW_TODO_STATE First entry
    
    * NEW_DONE_STATE Second entry'''
    doc = loads(orig, environment={
      'org-todo-keywords': "NEW_TODO_STATE | NEW_DONE_STATE"
    })
    

Knowledge Management

Aleph

  • New: API Usage.

    The Aleph web interface is powered by a Flask HTTP API. Aleph supports an extensive API for searching documents and entities. It can also be used to retrieve raw metadata, source documents and other useful details. Aleph's API tries to follow a pragmatic approach based on the following principles:

    • All API calls are prefixed with an API version; this version is /api/2/.
    • Responses and requests are both encoded as JSON. Requests should have the Content-Type and Accept headers set to application/json.
    • The application uses Representational State Transfer (REST) principles where convenient, but also has some procedural API calls.
    • The API allows API Authorization via an API key or JSON Web Tokens.

    Authentication and authorization

    By default, any Aleph search will return only public documents in responses to API requests.

    If you want to access documents which are not marked public, you will need to sign into the tool. This can be done through the use on an API key. The API key for any account can be found by clicking on the "Profile" menu item in the navigation menu.

    The API key must be sent on all queries using the Authorization HTTP header:

    Authorization: ApiKey 363af1e2b03b41c6b3adc604956e2f66

    Alternatively, the API key can also be sent as a query parameter under the api_key key.

    Similarly, a JWT can be sent in the Authorization header, after it has been returned by the login and/or OAuth processes. Aleph does not use session cookies or any other type of stateful API.

  • New: Crossreferencing mentions with entities.

    Mentions are names of people or companies that Aleph automatically extracts from files you upload. Aleph includes mentions when cross-referencing a collection, but only in one direction.

    Consider the following example:

    • "Collection A" contains a file. The file mentions "John Doe".
    • "Collection B" contains a Person entity named "John Doe".

    If you cross-reference “Collection A”, Aleph includes the mention of “John Doe” in the cross-referencing and will find a match for it in “Collection B”.

    However, if you cross-reference “Collection B”, Aleph doesn't consider mentions when trying to find a match for the Person entity.

    As long as you only want to compare the mentions in one specific collection against entities (but not mentions) in another collection, Aleph’s cross-ref should be able to do that. If you want to compare entities in a specific collection against other entities and mentions in other collections, you will have to do that yourself.

    If you have a limited number of collection, one option might be to fetch all mentions and automatically create entities for each mention using the API.

    To fetch a list of mentions for a collection you can use the /api/2/entities?filter:collection_id=137&filter:schemata=Mention API request.

Coding

Languages

Configure Docker to host the application

Python Snippets

  • New: Send a linux desktop notification.

    To show a Linux desktop notification from a Python script, you can use the notify2 library (although it's last commit was done on 2017. This library provides an easy way to send desktop notifications on Linux.

    Alternatively, you can use the subprocess module to call the notify-send command-line utility directly. This is a more straightforward method but requires notify-send to be installed.

    import subprocess
    
    def send_notification(title: str, message: str = "", urgency: str = "normal") -> None:
        """Send a desktop notification using notify-send.
    
        Args:
            title (str): The title of the notification.
            message (str): The message body of the notification. Defaults to an empty string.
            urgency (str): The urgency level of the notification. Can be 'low', 'normal', or 'critical'. Defaults to 'normal'.
        """
        subprocess.run(["notify-send", "-u", urgency, title, message])
    
  • New: Get the error string.

    import traceback
    
    def cause_error():
        return 1 / 0  # This will raise a ZeroDivisionError
    
    try:
        cause_error()
    except Exception as error:
        # Capture the exception traceback as a string
        error_message = "".join(traceback.format_exception(None, error, error.__traceback__))
        print("An error occurred:\n", error_message)
    

Coding tools

Coding with AI

  • New: Add new prompts for developers.

      - trigger: :polish
        form: |
         Polish the next code
         [[code]]
         with the next conditions:
         - Use type hints on all functions and methods
         - Add or update the docstring using google style on all functions and methods
        form_fields:
          code:
            multiline: true
      - trigger: :commit
        form: |
         Act as an expert developer. Create a message commit with the next conditions:
         - follow semantic versioning
         - create a semantic version comment per change
         - include all comments in a raw code block so that it's easy to copy
    
         for the following diff
         [[text]]
        form_fields:
          text:
            multiline: true
    

Espanso

  • New: Desktop application to add words easily.

    Going into the espanso config files to add words is cumbersome, to make things easier you can use the espansadd Python script.

    I'm going to assume that you have the following prerequisites:

    • A Linux distribution with i3 window manager installed.
    • Python 3 installed.
    • Espanso installed and configured.
    • ruyaml and tkinter Python libraries installed.
    • notify-send installed.
    • Basic knowledge of editing configuration files in i3.

    Installation

    Create a new Python script named espansadd.py with the following content:

    import tkinter as tk
    from tkinter import simpledialog
    import traceback
    import subprocess
    import os
    import sys
    
    from ruyaml import YAML
    from ruyaml.scanner import ScannerError
    
    file_path = os.path.expanduser("~/.config/espanso/match/typofixer_overwrite.yml")
    
    def append_to_yaml(file_path: str, trigger: str, replace: str) -> None:
        """Appends a new entry to the YAML file.
    
        Args:ath
            file_path (str): The file to append the new entry.
            trigger (str): The trigger string to be added.
            replace (str): The replacement string to be added.
        """
    
        # Define the new snippet
        new_entry = {
            "trigger": trigger,
            "replace": replace,
            "propagate_case": True,
            "word": True,
        }
    
        # Load existing data or initialize an empty list
        try:
            with open(os.path.expanduser(file_path), "r") as f:
                try:
                    data = YAML().load(f)
                except ScannerError as e:
                    send_notification(
                        f"Error parsing yaml of configuration file {file_path}",
                        f"{e.problem_mark}: {e.problem}",
                        "critical",
                    )
                    sys.exit(1)
        except FileNotFoundError:
            send_notification(
                f"Error opening the espanso file {file_path}", urgency="critical"
            )
            sys.exit(1)
    
        data["matches"].append(new_entry)
    
        # Write the updated data back to the file
        with open(os.path.expanduser(file_path), "w+") as f:
            yaml = YAML()
            yaml.default_flow_style = False
            yaml.dump(data, f)
    
    def send_notification(title: str, message: str = "", urgency: str = "normal") -> None:
        """Send a desktop notification using notify-send.
    
        Args:
            title (str): The title of the notification.
            message (str): The message body of the notification. Defaults to an empty string.
            urgency (str): The urgency level of the notification. Can be 'low', 'normal', or 'critical'. Defaults to 'normal'.
        """
        subprocess.run(["notify-send", "-u", urgency, title, message])
    
    def main() -> None:
        """Main function to prompt user for input and append to the YAML file."""
        # Create the main Tkinter window (it won't be shown)
        window = tk.Tk()
        window.withdraw()  # Hide the main window
    
        # Prompt the user for input
        trigger = simpledialog.askstring("Espanso add input", "Enter trigger:")
        replace = simpledialog.askstring("Espanso add input", "Enter replace:")
    
        # Check if both inputs were provided
        try:
            if trigger and replace:
                append_to_yaml(file_path, trigger, replace)
                send_notification("Espanso snippet added successfully")
            else:
                send_notification(
                    "Both trigger and replace are required", urgency="critical"
                )
        except Exception as error:
            error_message = "".join(
                traceback.format_exception(None, error, error.__traceback__)
            )
            send_notification(
                "There was an unknown error adding the espanso entry",
                error_message,
                urgency="critical",
            )
    
    if __name__ == "__main__":
        main()
    

    Ensure the script has executable permissions. Run the following command:

    chmod +x espansadd.py
    

    To make the espansadd script easily accessible, we can configure a key binding in i3 to run the script. Open your i3 configuration file, typically located at ~/.config/i3/config or ~/.i3/config, and add the following lines:

    bindsym $mod+Shift+e exec --no-startup-id /path/to/your/espansadd.py
    

    Replace /path/to/your/espansadd.py with the actual path to your script.

    If you also want the popup windows to be in floating mode add

    for_window [title="Espanso add input"] floating enable
    

    After editing the configuration file, reload i3 to apply the changes. You can do this by pressing Mod + Shift + R (where Mod is typically the Super or Windows key) or by running the following command:

    i3-msg reload
    

    Usage

    Now that everything is set up, you can use the espansadd script by pressing Mod + Shift + E. This will open a dialog where you can enter the trigger and replacement text for the new Espanso snippet. After entering the information and pressing Enter, a notification will appear confirming the snippet has been added, or showing an error message if something went wrong.

Operating Systems

Linux

Wireguard

  • New: Check the status of the tunnel.

    One method is to do ping between VPN IP addresses or run command wg show`` from the server or from the client. Below you can seewg show`` command output where VPN is not up.

    $: wg show
    interface: wg0
      public key: qZ7+xNeXCjKdRNM33Diohj2Y/KSOXwvFfgTS1LRx+EE=
      private key: (hidden)
      listening port: 45703
    
    peer: mhLzGkqD1JujPjEfZ6gkbusf3sfFzy+1KXBwVNBRBHs=
      endpoint: 3.133.147.235:51820
      allowed ips: 10.100.100.1/32
      transfer: 0 B received, 592 B sent
      persistent keepalive: every 21 seconds
    

    The below output from the wg show command indicates the VPN link is up. See the line with last handshake time

    $: wg show
    interface: wg0
      public key: qZ7+xNeXCjKdRNM33Diohj2Y/KSOXwvFfgTS1LRx+EE=
      private key: (hidden)
      listening port: 49785
    
    peer: 6lf4SymMbY+WboI4jEsM+P9DhogzebSULrkFowDTt0M=
      endpoint: 3.133.147.235:51820
      allowed ips: 10.100.100.1/32
      latest handshake: 14 seconds ago
      transfer: 732 B received, 820 B sent
      persistent keepalive: every 21 seconds