semvec/pypi-packages huggingface dataset:
discord-ext-track-edits 0.1.2
A discord.py extension for automatic edit tracking
Requires Python: >=3.8
Keywords: discord, edit tracking, extension, discord-ext

# discord-ext-track-edits

A [discord.py](https://github.com/Rapptz/discord.py) extension that implements
edit tracking for prefix commands, inspired by [poise](https://github.com/serenity-rs/poise):
- When user edits their message, automatically update bot response
- When user deletes their message, automatically delete corresponding
bot response, if it exists.

## Usage

The extension contains an `EditTrackerCog` and an `EditTrackableContext`. They must
be used together for edit tracking to work.

Responses will be tracked only when you explicitly `.reply()` to the invocation message.

```python
from datetime import timedelta
from typing import Type, Union
from typing_extensions import override

import discord
from discord.ext import commands
from discord.ext.track_edits import EditTrackerCog, EditTrackableContext

class Bot(commands.Bot):
    async def setup_hook(self) -> None:
        await self.add_cog(
            EditTrackerCog(
                self,
                max_duration=timedelta(minutes=5),
                execute_untracked_edits=True,
                ignore_edits_if_not_yet_responded=False,
            ),
        )

    @override
    async def get_context(
        self,
        origin: Union[discord.Message, discord.Interaction],
        *,
        cls: Type[EditTrackableContext] = EditTrackableContext,
    ) -> EditTrackableContext:
        return await super().get_context(origin, cls=cls)

# your usual bot setup code here
```

## Cog options
- `max_duration`: How long to track bot responses for. If set to `None`, bot
responses will be tracked indefinitely until the process is shut down.
(default: 5 minutes)
- `execute_untracked_edits`: Whether to execute a command that was previously
untracked, for example, when the user makes a typo and edits it into a valid
invocation. (default: `True`)
- `ignore_edits_if_not_yet_responded`: Whether to ignore edits on messages
that have not been responded to. This happens if the edits happens before the
command has sent a response, or if the command does not respond at all.
(default: `False`)

## Command options
Command options are supplied through the `extras` dictionary:

```python
@commands.command(extras={"invoke_on_edit": False})
async def cmd(ctx):
    ...
```

- `invoke_on_edit`: Whether to rerun the command if an existing invocation
message is edited (default: `True`)
- `track_deletion`: Whether to delete the bot response if an existing invocation
message is deleted (default: `True`)
- `reuse_response`: Whether to post subsequent responses as edits to the original
response (default: `True`)
dotocli 0.1.0
Package Manager Utility
Requires Python: >=3.12

# doto

Dotfiles management with Python and Ansible
This tool aims to be `poetry` for `Ubuntu`.
It helps maintaing a manifest file that keeps track of the packages and other setting to apply to a system.

Similar to `poetry` you can run `doto add [package]` which will add the package to the manifest file and install it.

The backend for the first version will be `Ansible` but with an abstaraction layer to be able to replace it in the future.

## Features

- Manage packages from different sources
- Manage hosts
  - This allows you to add package to a specific host. For example if you have a workstation and a laptop you might want to apply different settings and packages.
- Add comments to package entries in the Manifest file.
- CLI to manage and view manifest file.
- Sync the manifest to a remote repository via `Git`
- Besides packages one can also choose to add and apply an `Ansible Role` which is maintained and tested in a separate repository.

- Testing and Dry run. By using the test tools available for `Ansible` one can add a package in a dry-run and create a VM to apply the new manifest to verify that the outcome is a expected.
Command could be `doto deploy host`

Future:
- The tool manages a local manifest file on each host to avoid to keep track of packages that are already installed.



## Data Structures

Overview of Data Structures:

- Manifest file
  - Hosts

- Host
  - Name
  - Platform
    - rpi
    - vm
    - x86
    - arm

  - Tags:
    - coding
    - workstation
    - laptop
    - video_editing
  - Packages

Packages don't require any configuration besides installing them.

- Package
  - name
  - version
  - comment

### Commands

`doto add [package]`
will check the available package managers for the package and ask which source to select.
A default can be set or the option `--package-manager` can be provided

- apt
- appimage
  - Github release page
- Flatpak
- Snap
- pypi

## Development

`docker build -t doto-ci .`
`docker run --rm -v $PWD:/workspaces/doto -w /workspaces/doto doto-ci bash -c 'poetry run inv python.ci'`
`docker run --rm -v $PWD:/workspaces/doto -w /workspaces/doto --user $(id -u):$(id -g) doto-ci bash -c 'poetry run inv python.ci'`

### Setup for development

## Ansible

Running ansible playbook

```bash
cd ansible
ansible-galaxy install -r requirements.yml
ansible-playbook -i inventory main.yml
```

## Vagrant

## VirtualBox

```bash
VBoxManage list runningvms | cut -d '"' -f 2 | xargs -I {} VBoxManage controlvm {} poweroff soft && VBoxManage list vms | cut -d '"' -f 2 | xargs -I {} VBoxManage unregistervm {} --delete
```

## TODO

- 2024-03-10:
  - Create PR:
    - <https://github.com/ansible/molecule/discussions/3914>
    - geerlingguy ansible playbook testing
  - Have a dir with shared molecule files like prepare.yml

- 2024-02-22:
  - molecule test does not create a box, I have to run molecule converge first.
  - virtulabox got installed and was signed automatically, need to figure out why. dpkg package?
dpg-components 0.0.4
Components for DPG
Requires Python: >=3.8

## dpg-components

 "A component is a piece of the UI (user interface) that has its own logic and appearance. A component can be as small as a button, or as large as an entire page." Components are a powerful abstraction.   

The goal of this project is to bring Components to [DearPyGui](https://github.com/hoffstadt/DearPyGui)   

 - Components should be first class citizens, i.e. use the same API as regular DPG Items.
 - Components can contain other Components or regular DPG Items.
 - Reusability is achieved through composition.

### How it works ?
Import module dpg_components, then you can interact with DPG as normal and also call the method "add_component" to add
complex components to your project. You can also define your own components by implementing abstract class "DPGComponent".

```python 
from datetime import datetime
import dpg_components
import dearpygui.dearpygui as dpg

def save_callback():
    print("Save Clicked")

dpg.create_context()
dpg.create_viewport()
dpg.setup_dearpygui()

with dpg.window(label="Example Window"):
    dpg.add_text("Hello world")
    dpg.add_button(label="Save", callback=save_callback)
    dpg.add_input_text(label="string")
    dpg.add_slider_float(label="float")

    ## add a Date Picker component
    dpg.add_component(dpg_components.DatePickerComp, tag=f'date_picker_1')
    # Set default date to today
    dpg.configure_item(f'date_picker_1', default_value = datetime.now().date())

dpg.show_viewport()
dpg.start_dearpygui()
dpg.destroy_context()
```
flowmotion 0.2.5
A Manim-based animation library for visualizing data structures and algorithms.
Requires Python: >=3.12

# 🌊 FlowMotion

**FlowMotion** is a modular animation framework built on [Manim](https://www.manim.community/) for visualizing data structures, algorithms, and logic flows in an intuitive and customizable way.

> Animate how your code thinks.

---

## 🎥 What is FlowMotion?

FlowMotion helps you create beautiful, step-by-step animations of:

- Data structures (arrays, stacks, queues, linked lists, etc.)
- Algorithm flows (sorting, searching, traversals)
- Pointer movements, swaps, highlights, and comparisons
- Custom visual debug traces and timeline flows

---

## 🚀 Features

- ✅ Scene-based architecture using Manim
- 🔁 Reusable visual components (`FlowArray`, `FlowPointer`, etc.)
- 🎯 Scheduling support (coming soon!)
- 🔍 Visual debugging tools
- 🧠 Educational & developer-friendly API
- 🛠️ Built for extensibility — create your own FlowBlocks

---

## 📦 Installation

```bash
pip install flowmotion