semvec/pypi-packages huggingface dataset:
django-unmanaged-mastodon 0.1.0
Unmanaged Django Models for Mastodon
Requires Python: >=3.10

# Unmanaged Django Models for Mastodon

![PyPI - License](https://img.shields.io/pypi/l/django_unmanaged_mastodon)
![PyPI - Version](https://img.shields.io/pypi/v/django_unmanaged_mastodon)

# Installation

```shell
uv add django-unmanaged-mastodon
# or
pip install django-unmanaged-mastodon
```

Configure `settings.py` with correct `INSTALLED_APPS`, `DATABASES`, and `DATABASE_ROUTER`

```python
# Add django_unmanaged_mastodon to installed apps
INSTALLED_APPS = [
    "myapp",
    "django_unmanaged_mastodon", # << Add to installed apps
    # Django
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
]

# https://docs.djangoproject.com/en/6.0/ref/settings/#databases
DATABASES = {
    "default": env.db_url(
        var="DATABASE_URL",
        default=f"sqlite:///{BASE_DIR}/db.sqlite3",
    ),
    # Configure additional database connection named 'django_unmanaged_mastodon'
    # for the module to use with the router
    "django_unmanaged_mastodon": env.db_url("DATABASE_MASTODON", default=None),
}

# https://docs.djangoproject.com/en/6.0/ref/settings/#database-routers
# Add the provided router
DATABASE_ROUTERS = ["django_unmanaged_mastodon.router.Router"]
```
lavaplay.py 1.0.19a0
Its a lavalink nodes manger to make a music bots for discord with python.
Keywords: lavalink, discord, discord-lavalink, lavaplay, lavaplay.py

<h1 align="center">
    <b>
        <a href="https://github.com/HazemMeqdad/lavaplay.py">
            lavaplay.py
        </a>
    </b>
</h1>


<p align="center">
    <a href="https://discord.gg/VcWRRphVQB">Support Guild</a> |
    <a href="https://github.com/HazemMeqdad/lavaplay.py/tree/main/examples">Examples</a> |
    <a href="https://lavaplay.readthedocs.io/en/latest/">Documentation</a> |
    <a href="https://github.com/HazemMeqdad/lavaplay.py">Source</a>
</p>

<br>

Its a lavalink nodes manger to make a music bots for discord with python.


# About

lavaplay.py is a nodes manager to connection with discord voice gateway, easy to create a music bot, you can use to anything async discord wrapper library

> [!NOTE]
> Lavaplay now support lavalink v4 ( 1.0.13a+ )

# Usage

example for create connecting with lavalink server using [hikari](https://github.com/hikari-py/hikari).

```python
import hikari
import lavaplay

bot = hikari.GatewayBot("token")

lavalink = lavaplay.Lavalink()
node = lavalink.create_node(
    host="localhost",
    port=2333,
    password="youshallnotpass",
    user_id=123
)

@bot.listen()
async def on_ready(event: hikari.ShardReadyEvent) -> None:
    node.connect()

bot.run()
```

examples for some methods.
```python
# Player object
player = node.get_player(guild_id)

# Auto search mix with track or query
await player.auto_search_tracks("Rick Astley")

# Play track
await player.play(track)

# Skip
await player.skip()

# Pause
await player.pause(stats)

# Volume
await player.volume(volume)
```

# Features

- [x] Lavalink v4 support ( 1.0.13a+ )
- [x] new Rest api for lavalink support
- [x] connection handler
- [ ] Multi-Node Support ( Coming soon )
- [x] Support youtube playlist
- [x] Add example for other discord wrapper library

# Installation

```shell
# Linux/OS X
$ pip3 install -U lavaplay.py

# Windows
$ pip install -U lavaplay.py
```
cl-keeper 0.0.0b6
A CLI tool for keeping your changelogs tidy
Requires Python: >=3.12

# ChangeLog Keeper

A CLI tool that helps you with maintaining `CHANGELOG.md`
using [keep a changelog] format.

## Resources

- [Documentation](https://cl-keeper.readthedocs.io/)
- [Issues](https://github.com/taminomara/cl-keeper/issues)
- [Source](https://github.com/taminomara/cl-keeper/)
- [PyPi](https://pypi.org/project/cl-keeper/)
- [Changelog](https://github.com/taminomara/cl-keeper/blob/main/CHANGELOG.md)

## GitHub action quickstart

Use `taminomara/cl-keeper@v1` to parse a change log. It takes git tag
(parameter `version`) and returns `text` and other release info.
See details in [documentation][GitHub Action].

**Example:**

```yaml
name: Create a release
  on:
    push:
      tags:
        - 'v*'
jobs:
  release:
    - name: Checkout source
      uses: actions/checkout@v4
    - id: changelog
      name: Parse Changelog
      uses: taminomara/cl-keeper@v1
      with:
        version: ${{ github.ref }}
    - name: Create GitHub release
      uses: softprops/action-gh-release@v2
      with:
        prerelease: ${{ fromJSON(steps.changelog.outputs.is-pre-release) }}
        draft: ${{ fromJSON(steps.changelog.outputs.is-unreleased) }}
        body: |
          ## Changelog

          ${{ steps.changelog.outputs.text }}
```

## Installation

Install [via pipx][pipx-install]:

```sh
pipx install cl-keeper
```

[GitHub Action]: https://cl-keeper.readthedocs.io/en/stable/advanced.html#using-changelog-keeper-in-github-actions
[keep a changelog]: https://keepachangelog.com/
[pipx-install]: https://cl-keeper.readthedocs.io/en/stable/installation.html#with-pipx
python-didl-lite 1.5.0
DIDL-Lite (Digital Item Declaration Language) tools for Python
Requires Python: >=3.10
Keywords: DIDL, DIDL-lite

DIDL-Lite (Digital Item Declaration Language) tools for Python
==============================================================

DIDL-Lite tools for Python to read and write DIDL-Lite-xml.

Usage
-----

See ``tests/`` for examples on how to use this.

Note that this package does **NOT** do any type checking. Coercion of data types from and to strings must be done by the user of this library.


Resources / documents
---------------------

DIDL-Lite resources and documents:

* `UPnP-av-ContentDirectory-v1-Service <http://upnp.org/specs/av/UPnP-av-ContentDirectory-v1-Service.pdf>`_
* `UPnP-av-ContentDirectory-v2-Service <http://upnp.org/specs/av/UPnP-av-ContentDirectory-v2-Service.pdf>`_
* `didl-lite-v2.xsd <http://www.upnp.org/schemas/av/didl-lite-v2.xsd>`_
* `mpeg21-didl <http://xml.coverpages.org/mpeg21-didl.html>`_


Releasing
---------

Steps for releasing:

- Switch to development: ``git checkout master``
- Do a pull: ``git pull``
- Run towncrier: ``towncrier build --version <version>``
- Commit towncrier results: ``git commit -m "Towncrier"``
- Run bump2version (note that this creates a new commit + tag): ``bump2version --tag major/minor/patch``
- Push to github: ``git push && git push --tags``
qtcompose 0.2.0
Build Qt applications in a reactive, declarative, and composable way
Requires Python: >=3.11

# qtcompose

Build Qt applications in a reactive, declarative, and composable way.

`qtcompose` lets you describe your UI as a tree of components whose properties are driven by reactive values. Update state and the UI updates automatically.

> [!WARNING]
> This project is under active development. APIs and behavior may change quickly, and documentation is still in progress. Feedback and early experimentation are welcome.


## Installation

```shell
pip install qtcompose
```

You’ll also need a Qt binding. The examples use PySide6.

```shell
pip install PySide6
```

## Quick example
A small counter app where the label updates automatically when count changes:

```python
from PySide6 import QtWidgets
from qtcompose.rx import Subject, fn
from qtcompose.ui import (
    QBoxLayoutItem,
    QLabel,
    QMainWindow,
    QPushButton,
    QVBoxLayout,
    QWidget,
)

app = QtWidgets.QApplication()

count = Subject(0)

window = QMainWindow(
    children=Subject(
        QWidget(
            layout=Subject(
                QVBoxLayout(
                    children=Subject(
                        [
                            QBoxLayoutItem.Child(
                                QLabel(
                                    text=fn.pipe(
                                        count,
                                        fn.map_(lambda cnt: f"Count: {cnt}")
                                    )
                                )
                            ),
                            QBoxLayoutItem.Child(
                                QPushButton(
                                    text=Subject("Click Me!"),
                                    on_click=Subject(
                                        lambda _: count.push(
                                            lambda prev: prev + 1
                                        )
                                    ),
                                )
                            ),
                        ]
                    )
                )
            )
        )
    )
)()

window.show()
app.exec()
```

## Further reading

For a deeper explanation of the ideas behind this project, check out my blog post:
- [From Imperative Qt to State-Driven UI Composition](https://lucapalmi.com/articles/from-imperative-qt-to-state-driven-ui-composition)
otio-kdenlive-adapter 0.0.3
Short description of your plugin

<!--
    SPDX-License-Identifier: CC-BY-SA-4.0
    SPDX-FileCopyrightText: 2022 Julius Künzel <jk.kdedev@smartlab.uber.space>
-->

# DEPRECATED

This OpenTimelineIO adapter is deprecated and not maintained anymore! Kdenlive has native support for OpenTimelineIO since version 25.04. This native integration offers more features and works much more reliable than the adapter does. See our [documentation for details](https://docs.kdenlive.org/en/user_interface/menu/file_menu.html#opentimelineio-import).

---

# OpenTimelineIO Kdenlive Adapter

This repository contains the OpenTimelineIO adapter for the Kdenlive file format (`*.kdenlive`). It is distributed under the MIT License.

## What is Kdenlive?

[Kdenlive](https://kdenlive.org) is a Free and Open Source video editing application, based on MLT Framework and KDE Frameworks.

In case you are looking for the source code of Kdenlive, it is here: https://invent.kde.org/multimedia/kdenlive

## What is OpenTimelineIO?

[OpenTimelineIO](https://opentimeline.io) is an interchange format and API for editorial cut information. OTIO contains information about the order and length of cuts and references to external media. It is not however, a container format for media.

For integration with applications, the [core OTIO library](https://github.com/AcademySoftwareFoundation/OpenTimelineIO) is implemented in C++ the project also supports an official python binding. The python binding includes a plugin system which supports a number of different types of plugins, most notably adapters (like this one).

### Adapter Plugins

To provide interoperability with other file formats or applications lacking a native integration, the opentimelineio community has built a number of python adapter plugins. Beside Kdenlive this includes Final Cut Pro XML, AAF, CMX 3600 EDL, and more.

For more information about this, including supported formats, see: https://opentimelineio.readthedocs.io/en/latest/tutorials/adapters.html

A list of tools and projects using OpenTimelineIO can be found [here](https://github.com/AcademySoftwareFoundation/OpenTimelineIO/wiki/Tools-and-Projects-Using-OpenTimelineIO).

## Installing

As a user you can usually just install the adapter through the Kdenlive user interface or directly from pypi.org with this command

```bash
python -m pip install otio-kdenlive-adapter
```

## Development

The OpenTimelineIO documentation can be found here: https://opentimelineio.readthedocs.io

### Testing the plugin during development
```bash
# In the root folder of the repo
pip install -e .

# Test an adapter for instance
otioconvert -i some_timeline.otio -o some_timeline.kdenlive
```

The OpenTimelineIO documentation can be found here: https://opentimelineio.readthedocs.io

### Unit tests

It's always a good idea to write unit tests for you code.
Please provide tests that run against supported versions of python and OpenTimelineIO.

To run the unit tests do
```bash
# In the root folder of the repo
pytest
```

Before pushing changes you should also run the linter
```bash
flake8 --show-source
```
correction-helper 2026.1.3
Some helpers to help writing correction bots, use by hackinscience.org.
Requires Python: >=3.7

# Correction Helper

## Project

This is just a set of tools to help writing correction bots in Python for Python.

It is used for [hackinscience](https://hackinscience.org), but could
be used elsewhere.


## Security considerations

Running student code is probably really unsafe, unless you trust your
students not to drop you a backdoor.

This projet does *not* help with security in any ways, maybe take a
look at [firejail](https://github.com/netblue30/firejail) if you have
trust issues (Yes you can use `correction-helper` inside `firejail`).


## Usage

To install it, run: `pip install correction-helper`.


In your checking code, you can use it like this:


### The `student_code` decorator

This decorator is aimed to catch most problems that could happen in
student code, use it simply as:

```python
with student_code():
    their_function()
```

Find a more complete example in the `examples/` directory.


## Allowed parameters for `student_code`, and their default values

### `exception_prefix="I got an exception:"`

Printed right before the exception, if any.

It's allowed to give a list of strings, in which case they'll be
separated by `"\n\n"`, useful to render markdown paragraphs.


### `print_prefix="Your code printed:"`

Message to display before the student prints (in case `print_allowed`
is `False` or `None`).

It's allowed to give a list of strings, in which case they'll be
separated by `"\n\n"`, useful to render markdown paragraphs.


### `too_slow_message="Your program looks too slow, looks like an infinite loop."`

Message to display in case the code runs slower than the given `timeout` (defaults to 1s).

It's allowed to give a list of strings, in which case they'll be
separated by `"\n\n"`, useful to render markdown paragraphs.


### `prefix=()`

A prefix for `print_prefix`, `exception_prefix`, and
`too_slow_message=`, usefull to deduplicate strings, like:

```python
with student_code(
    prefix="While calling blahblah('bar')",
    print_prefix="it printed:",
    exception_prefix="it raised:",
    too_slow_message="it took more than 1s, had to kill it.",
):
    blahblah('bar')
```


### `friendly=False`

To use, or not
[friendly-traceback](https://github.com/aroberge/friendly-traceback/)
instead of bare Python exceptions.


### `print_allowed=True`

To allow or deny the student to print to stdout and stderr.

- `True`: Prints are allowed (and displayed).
- `None`: Prints are allowed (but not displayed).
- `False`: Prints are disallowed (and displayed).

In all cases you can read what they printed using the value of the
context manager:

```python
with student_code(print_allowed=None) as run:
    their_function()
assert run.err == ""
assert run.out == "42"
```


## Good practices

Write the student checking code a you would write unit test for your
own code.