An asynchronous MInecraft server votifier client in Python

from aiovotifier import VotifierClient
import asyncio

async def main():
    client = VotifierClient("127.0.0.1", 8192, "testservicename", "token/rsa key")
    
    # VotifierClient.vote(...) automatically determines the protocol and key format
    await client.vote("username", "user address")
    await client.vote("user2")

    await client.v1_vote("username", "user address")  # only supports v1 protocol
    await client.nu_vote("username", "user address")  # only supports NuVotifier/v2 protocol

asyncio.run(main())

• Arguments:
  • host: str – The hostname or IP of the votifier server
  • port: int – The port of the votifier server, commonly 8192
  • service_name: str – The name of the service that sends the vote
  • secret: str – The public RSA key or the token found in config.yml
• Methods:
  • vote(username: str, user_address: str = "127.0.0.1") – sends a vote to the votifier server, automatically detects and handles the protocol and type of secret
  • v1_vote(username: str, user_address: str = "127.0.0.1") – sends a Votifier v1 vote to a votifier v1 server
  • nu_vote(username: str, user_address: str = "127.0.0.1") -> dict – sends a NuVotifier / v2 vote to a NuVotifier server, returns the response from the server

• Arguments:
  • header: bytes – The header received from the votifier server
  • version: str – The version of the votifier server
  • challenge: str = None – The challenge, included only if the votifier server is v2/NuVotifier
• Methods:
  • @classmethod parse(header: bytes) – Returns a new VotifierHeader, parsed from the input bytes

• Sends a Votifier v1 vote to a Votifier v1 server

• Sends a NuVotifier / v2 vote to a NuVotifier server

• Base class that all votifier exceptions derive from

• Raised when the header from the votifier server is invalid

• Raised when the votifier version is unsupported

• Raised when the response from the votifier server contains a status that is not OK

aiovotifier was based off the code and documentation below

• https://github.com/ano95/votifier2-py
• https://www.npmjs.com/package/votifier-client/v/0.1.0?activeTab=dependents
• https://github.com/vexsoftware/votifier
• https://github.com/NuVotifier/NuVotifier/wiki/Technical-QA

symlink-free dotfiles using the $HOME as the git work-tree technique

Used daily on macOS & BluefinDX/Bazzite/BazziteDX Fedora Linux systems.

• Quickstart
  • Manual post-clone steps
• Longstart
• Tips
• Tools
• Git Conditional Configuration
• Creating your own git work-tree dotfiles repository
• Licence

1. Clone the bare repository (this stores the Git history without checking out files yet):

   git clone --bare https://github.com/jthegedus/dotfiles.git "$HOME/.dotfiles.git"

2. Define a temporary alias for interacting with the dotfiles repo:

   alias dotfiles='git --git-dir="$HOME/.dotfiles.git/" --work-tree="$HOME"'

3. Attempt to checkout the files:

   dotfiles checkout

4. Handle Conflicts: If the checkout command fails due to existing files you can perform one of two actions:

   • a) Backup existing files and replace (recommended):

      # eg: backup the existing .config directory and git checkout
      mv ~/.config ~/.config.bak
      dotfiles checkout

     Repeat the above for any other reported conflicting folders/files.

   • b) Overwrite existing files with force checkout:

      dotfiles checkout -f

5. Configure the repository to ignore other untracked files in $HOME:

   dotfiles config --local status.showUntrackedFiles no

This creates the following files in your $HOME directory:

# in $HOME
.config/**      <-- configuration files
.dotfiles/      <-- template files for this repo
.dotfiles.git/  <-- .git dir for this repo
.gitconfig      <-- core git config file
.gitconfig.proj <-- created from .dotfiles/*.template
README.md       <-- this repo README
.zshenv         <-- tell ZSH to look at ~/.config/zsh/*

• Copy the template cp ~/.dotfiles/.gitconfig.project.template ~/.gitconfig.proj
• Fill out the name and email properties in ~/.gitconfig.proj
• If you do NOT wish to use SSH with Git then:
  • remove the gpg, commit, tag, and user sections from the file
• If you wish to use SSH with Git then:
  • fill out the signingkey properties in ~/.gitconfig.proj
  • Create and Store an SSH key and use for Authentication/Commit-Signing in GitHub
  • I recommend using BitWarden or an equivalent as an SSH Agent for secure storage and ease of use.

Install tools in .config/brewfile/Brewfile* using Homebrew and Homebrew File:

• brew install rcmdnk/file/brew-file
• brew file install

• Fork this repository
• Modify the contents using the in-browser GitHub edit & commit capabilities
• Remove the SSH git configuration if you do not wish to use SSH
• Clone the repository to your machine from your own Fork
• Follow the above Manual post-clone steps instructions

• I recommend using Fish over ZSH. ZSH configuration is here for convenience but I am considering dropping maintenance of it.
• Fork and modify this repository instead of cloning it directly.
  • Files that may require modification are:
    • .zshenv
    • .config/brewfile/Brewfile*
• Instead of using branching codepaths in your scripts for system-specific configurations you could use git branches to manage a copy for each system, with common/shared configuration in the master branch.
  • You would have to merge the common/shared configuration into the other branches on change.

I use Development Containers in most projects to manage project-specific dependencies. This keeps my OS installation relatively clean. Since devcontainers can mount your home directory, this repository contains some configuration files for tooling I commonly use within devcontainers that may not appear on my machine and therefore Brewfile.

The list of tools I use as a base on each system/OS are:

• fish: shell
• git: source control
• carapace: terminal completions
• macchina: terminal util
• starship: terminal prompt
• ghostty: terminal
• visual studio code: code editor (use vscode native settings sync)
• zed: code editor

Use the following tools to change the shell on most Unix systems:

• chsh -s $(which <DESIRED_SHELL>) $USER
• sudo usermod --shell $(which <DESIRED_SHELL) $USER (when chsh is not available)

I use the .gitconfig conditional includeIf directive to manage per-project Git settings in a separate configuration file to the ones committed to this repository (see the template in .dotfiles/.gitconfig.project.template directory for an example).

This is useful to manage different usernames, emails or authentication settings per project.

The includeIf directive allows for the following conditionals:

• gitdir:<pattern>: Matches if the Git directory path matches the pattern, useful for applying settings to projects in specific locations (e.g., ~/work/).
• onbranch:<branch-name-pattern>: Matches if the current branch name matches the pattern, useful for branch-specific workflows or settings.
• hasconfig:remote.<name>.url:<pattern>: Matches if a remote’s URL matches the pattern, useful for loading different user configs for work vs. personal projects or different Git platforms.

See the documentation for full explanations – https://git-scm.com/docs/git-config#_conditional_includes

As an example, this configuration applies the same config for remotes using GitHub via SSH & HTTPS, with another config for a singular organisation remote on BitBucket:

# git settings - GitHub SSH & HTTPS
[includeIf "hasconfig:remote.*.url:https://github.com/**"]
	path = ~/.gitconfig.proj
[includeIf "hasconfig:remote.*.url:git@github.com:**"]
	path = ~/.gitconfig.proj

# git settings - project specific SSH
#    NOTE: ensure this does not overlap with any other includeIf conditions
[includeIf "hasconfig:remote.*.url:git@bitbucket.org:<organisation_name>/**"]
	path = ~/<org_name>/.gitconfig.proj_<project_name>

This includes the specified configuration file if the repository you are running git commands against ( where the .git directory is) matches the provided pattern.

Here is a quick guide to creating your own bare repository for dotfiles using the $HOME as the git work-tree technique:

• create a bare repository
• set a temporary alias to use the bare repository (you should add this alias to your shell config as well for future use)
• set the repo to ignore all untracked files (using our alias “dotfiles”)
• set the remote origin to your GitHub (or other) repository

git init --bare $HOME/.dotfiles.git
alias dotfiles='git --git-dir=$HOME/.dotfiles.git/ --work-tree=$HOME'
dotfiles config --local status.showUntrackedFiles no
dotfiles remote add origin git@github.com:<username>/<repo>.git

Now add any of your existing .config files, track with git & push:

cd $HOME
dotfiles add .config/starship.toml
dotfiles status
dotfiles commit -m "feat: capture starship configuration"
dotfiles push

For more examples and inspiration see the HackerNews post where I learnt about this technique.

NB: The dotfiles alias is a temporary alias for the current shell session. I include it in my Fish & ZSH configuration files in this repository as a permanent way to quickly interact with my dotfiles repository.

NB: Even though all files are untracked thanks to the status.showUntrackedFiles no setting, I still recommend using .gitignore files when the configuration you wish to include is in a directory with other files you do not wish to include. This is purely a precautionary measure to avoid accidents. Though allow-listing files in .gitignore is a recommended practice.

Zero-Clause BSD
=============

Permission to use, copy, modify, and/or distribute this software for
any purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL
WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE
FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY
DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

Lizard is a lightweight wrapper on top of Bun, a fast all-in-one JavaScript runtime. This project provides a simple and efficient way to create web applications with minimal setup.

• Fast and Lightweight: Built on Bun, ensuring high performance.
• Simple Routing: Define routes easily with support for dynamic parameters.
• Middleware Support: Add middleware functions to handle requests.
• TypeScript Support: Written in TypeScript for type safety and better development experience.

To install dependencies, run:

bun install

To start the application, run:

bun run index.ts

The server will start on port 3000 by default.

├── .gitignore
├── bun.lockb
├── index.ts
├── lizard.ts
├── package.json
├── README.md
├── tsconfig.json
├── types.ts
├── utils.test.ts
└── utils.ts

• index.ts: Entry point of the application.
• lizard.ts: Core framework implementation.
• types.ts: Type definitions for the framework.
• utils.ts: Utility functions used by the framework.
• utils.test.ts: Unit tests for utility functions.

Here is an example of how to define routes in your application:

import Lizard from "./lizard";
import type { Middleware } from "./types";

const app = Lizard.create();

// Global middleware to log requests
const loggerMiddleware: Middleware = async (event, next) => {
	console.log(`Request: ${event.method} ${event.url}`);
	return next();
};

// Global middleware to add a custom header
const headerMiddleware: Middleware = async (event, next) => {
	event.response.headers.set('X-Custom-Header', 'Lizard');
	return next();
};

// Apply global middlewares
app.use(loggerMiddleware);
app.use(headerMiddleware);

app.get("https://github.com/", async (event) => {
	return event.response.send("Hello, World!");
});

app.get('/home', async (event) => {
	return event.response.send("Home Page");
});

app.get('/home/:id', async (event) => {
	return event.response.send("Home Page" + event.params?.id);
});

app.get('/home/:id', async (event) => {
	return event.response.send(`User ${event.params?.id}`);
});

app.get('/home/:id', async (event) => {
	return event.response.send(`User ${event.params?.id}`);
});

app.get('/home/:id/profile', async (event) => {
	return event.response.send(`User ${event.params?.id} Profile`);
});

app.post('/user', async (event) => {
	return event.response.send("User Created");
});

app.put('/user/:id', async (event) => {
	return event.response.send(`User ${event.params?.id} Updated`);
});

app.del('/user/:id', async (event) => {
	return event.response.send(`User ${event.params?.id} Deleted`);
});


app.listen(3000);

In this example, the middleware sets a user object in the event.locals property. The /profile route then accesses this local variable and returns the user’s name in the response.

This project is licensed under the MIT License.