semvec/pypi-packages huggingface dataset:
silence-remover-ad 1.0.0
A module to remove silence part with a user-friendly UI
Requires Python: >=3.8
Keywords: video, audio, silence, silent, remover, remove, ffmpeg

Raw video footage can be a hassle to process; and in particular long periods of silences can be superfluous.
The goal of this Python module is to provide a tool to remove video footage from the "silent part".
 This can be used by humans to increase density of information of their video, or to train AI models only on unsilenced part.
 It revolves heavily around "ffmpeg".
qcore-utils 2025.12.2
Utils Library
Requires Python: <3.14,>=3.11

[![Build Status](https://quakecoresoft.canterbury.ac.nz/jenkins/job/qcore/badge/icon?build=last:${params.ghprbActualCommit=master)](https://quakecoresoft.canterbury.ac.nz/jenkins/job/qcore)

## Installation:

To install run `pip install -e .` from the root directory of this repository

### Downloading data after install

After installing, if you intend to use GMT for plotting you will need to run "download_data.py" (Located in qcore.data) to download and
unpack the data used for these scripts
wanalysis 1.0.1
This is wanalysis, a module for microtonal analysis

# Wanalysis, a mini library for microtonal analysis, like compare EDOs, absolute error, ratios, etc.
Compare EDOs (EDO = Equal Division of Octave), Cents, etc. In python?
1. What's the module **wamusica**?
    Wamusica is a module of wanalysis, compare EDOs, absolute error and relative error, etc. (microtonality), wamusica is only data for APIs
2. What's the module watexto?
    Watexto is the **visual wamusica**, It's like this:
    * watexto is for *humans*
    * and wamusica is for *PCs*
3. How do I install it?
    You only need Python 3.6 or more, Why? f-strings :3
    Now you can install it with ```pip install wanalysis``` (published in [PyPI](https://pypi.org/project/wanalysis/))
4. How do I use this?
    If you need data: use wamusica, If you need text: use watexto
    Wanalysis is open source
5. Some examples:
    Code in Wamusica:
    * Code:
        ```PY
        import wanalysis.wamusica as wm

        print(wm.compare(5/4, [12, 17]))
        ```
    * Console:
        ```PY
        {'12-edo': {'abs_error': 13.68629, 'rel_error': 0.03543}, '17-edo': {'abs_error': 33.37254, 'rel_error': 0.08639}}
        ```

    Other code in wamusica:
    * Code:
        ```PY
        import wanalysis.wamusica as wm

        print(wm.results(7/4, 31))
        ```
    * Console:
        ```PY
        {'steps_of_31-edo': {'steps': 25, 'cents': 967.74194}, 'cents_of_1.750': 968.82591, 'abs_error': 1.08397, 'rel_error': 0.00112}
        ```

    Code in Watexto:
    * Code
        ```PY
        import wanalysis.watexto as wtxt

        print(wtxt.text_results(5/4, 17))
        ```
    * Console:
        ```
        Steps of 17-edo: 5 (352.941 cents)
        Cents of 1.250: 386.314 cents
        Absolute error: 33.373 cents
        Relative error: 8.6387%

        ```
Thanks for read!
popoto-shell 0.2.0
Package containing the Popoto Modem Python API.
Requires Python: >=3.9

# pshell
Python shell pshell and default_shell
# Installing package from gitlab
To install the from the gitlab pypi package repository follow these steps:
## Create an acess token
1. Go to your gitlab profile settings
2. Click on "Access Tokens"
3. Create a new access token with the following scopes:
   - `read_api`
   - `read_repository`
   - `read_package_registry`
4. Copy the access token, you will need it later.
## Create a pip configuration file
Create a file named `pip.conf` in your home directory (e.g., `~/.pip/pip.conf` on Linux/MacOS or `%APPDATA%\pip\pip.conf` on Windows) and add the following content:
```ini
[global]
index-url = https://__token__:<your_access_token>@gitlab.popotomodem.com/api/v4/projects/138/packages/pypi/simple
```
## Install the package
Now you can install the package using pip:

For the latest version:
```bash
pip install popotoshell
```

For a specific version:
```bash
pip install popotoshell==<version>
```

Example:
```bash
pip install popotoshell
# or for a specific version
pip install popotoshell==0.0.1+seng333.7343
```
# Development
To contribute to the project, you can clone the repository and devolop locally or in the included dev container.
## Cloning the repository
```bash
git clone git@gitlab.popotomodem.com:delresearch/pshell.git
```
## Setting up the development environment
You can use the included dev container for development. To do this, follow these steps:
1. Open the repository in Visual Studio Code.
2. Install the "Dev Containers" extension if you haven't already.
3. A notification should appear asking if you want to reopen the repository in a container. Click "Reopen in Container". **Note**: If the notification does not appear, you can manually open the command palette (Ctrl+Shift+P or Cmd+Shift+P) and select "Dev Containers: Rebuild and Reopen in Container".
4. Wait for the container to build and start.
   **Note**: If there are any issues with the container build, it's usually related to the mounts in the `devcontainer.json` file. Make sure you have a .ssh directory in your home directory, and a .gitconfig file in your home directory.
5. Once the container is running, you can open a terminal in the container and run the following command to install the package in editable mode:
```bash
pip install -e .
```
### Note for commits
When making commits, please ensure that you are putting a Jira ticket number in the commit message or that your branch name contains a Jira ticket number. This is important for tracking changes and linking them to the relevant tasks in our project management system.
If you are working on a feature or bug fix that is not directly linked to a Jira ticket, please create a new ticket and link it to your commit. This helps maintain clarity and organization in our development process.
cua-bench-ui 0.7.0
Lightweight webUI window controller for CUA bench using pywebview
Requires Python: >=3.12

# CUA Bench UI

Lightweight webUI window controller for CUA bench environments using pywebview

## Usage

```python
from bench_ui import launch_window, get_element_rect, execute_javascript

# Launch a window with inline HTML content
pid = launch_window(html="<html><body><h1>Hello</h1></body></html>")

# Get element rect in screen space
rect = get_element_rect(pid, "h1", space="screen")
print(rect)

# Execute arbitrary JavaScript
text = execute_javascript(pid, "document.querySelector('h1')?.textContent")
print(text)
```

## Installation

```bash
pip install cua-bench-ui
```
django-comments-xtd 2.10.11
Commenting Django app with threads, follow up notifications and email confirmation.
Requires Python: >=3.10

Work on version 3 is taking place in the branch [v3-2nd-attempt](https://github.com/danirus/django-comments-xtd/tree/v3-2nd-attempt). Version 3 will be backward incompatible.

# django-comments-xtd  [![tests](https://github.com/danirus/django-comments-xtd/workflows/tests/badge.svg)](https://github.com/danirus/django-comments-xtd/actions/workflows/ci-pipeline.yml)

A Django pluggable application that adds comments to your project.

<p align="center"><img align="center" src="https://github.com/danirus/django-comments-xtd/blob/raw/v2/docs/images/cover.light.png"></p>

It extends the original [Django Comments Framework](https://pypi.python.org/pypi/django-contrib-comments) with the following features:

* Thread support, so comments can be nested.
* Customizable maximum thread level, either for all models or on a per app.model basis.
* Optional notifications on follow-up comments via email.
* Mute links to allow cancellation of follow-up notifications.
* Comment confirmation via email when users are not authenticated.
* Comments hit the database only after they have been confirmed.
* Registered users can like/dislike comments and can suggest comments removal.
* Template tags to list/render the last N comments posted to any given list of app.model pairs.
* Emails sent through threads (can be disable to allow other solutions, like a Celery app).
* Fully functional JavaScript plugin using ReactJS, Bootstrap 5.3 and Remarkable.

From v2.10.10 django-comments-xtd includes support for [drf-spectacular](https://pypi.org/search/?q=drf-spectacular).

Example sites and tests run under officially Django [supported versions](https://www.djangoproject.com/download/#supported-versions):

* Django 6.0, 5.1, 5.0, 4.2, 4.1
* Python 3.14, 3.13, 3.12, 3.11, 3.10

Additional Dependencies:

* django-contrib-comments >=2.2
* djangorestframework >=3.12,<3.17


Check out the tutorial and examples in the [documentation](http://readthedocs.org/docs/django-comments-xtd/).