semvec/pypi-packages huggingface dataset:
appdex 0.1.1
A highly opinionated CLI tool for installing and setting up apps on debian-based systems.
Requires Python: <4.0,>=3.12

# Appdex

A highly opinionated CLI tool for installing and setting up apps on debian-based systems.

## Features

- Install and setup apps & packages

## Prerequisites

- [Advanced Package Tool (APT)](https://wiki.debian.org/Apt)
- [wget](https://www.gnu.org/software/wget/)
- [curl](https://curl.se/)

## Installation

```shell
pip install appdex
```

## Usage

```shell
appdex --help
```

## Usage (without installing)

```shell
pipx run appdex --help
```

or

```shell
python -m appdex --help
```

## Examples

All examples will show using `appdex` as a command (installed). All uses of `appdex` are interchangeable with
`python -m appdex` and `pipx run appdex`.

### Run install wizard

This will prompt you to select which apps to install.

```shell
appdex install
```

### Install all apps

This will install all apps. Prompting you with any questions that are required from tools like `apt`.

```shell
appdex install all
```

### Install all apps, accepting all prompts

(Coming soon)
This will install all apps. Accepting all prompts. This flag works with all commands.

```shell
appdex install all --accept-all-prompts
```

## License

This project is licensed under the TBA License - see the [LICENSE](LICENSE) file for details
metalibraries 0.2.3
Metalibraries is a Python package that provides modular, reusable libraries designed to streamline development and improve code organization across various projects.
Requires Python: >=3.10

This is free and unencumbered software released into the public domain.

Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any
means.

In jurisdictions that recognize copyright laws, the author or authors
of this software dedicate any and all copyright interest in the
software to the public domain. We make this dedication for the benefit
of the public at large and to the detriment of our heirs and
successors. We intend this dedication to be an overt act of
relinquishment in perpetuity of all present and future rights to this
software under copyright law.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.

For more information, please refer to <https://unlicense.org>


# Overview
Metalibraries is a Python package designed to enhance your development workflow by providing a collection of modular, reusable libraries. These libraries are crafted to improve code organization, boost efficiency, and simplify integration across various projects.

# Highlights
Modular Libraries: A suite of components tailored for diverse tasks.
Enhanced Code Management: Streamline your codebase with organized, well-defined modules.
Reusable Components: Avoid redundancy and maximize efficiency by reusing code.
Flexible Integration: Easily incorporate libraries into any project with minimal configuration.

# Installation
To get started with Metalibraries, install it using pip:
pip install metalibraries

# How It Works
Library Integration: Import the necessary libraries from Metalibraries and configure them as required for your project.
Customization: Adjust the components to fit specific project needs, ensuring flexibility and adaptability.
Contribution Guide
We welcome contributions from the community! To contribute:

# Fork the repository
Create a new branch for your changes.
Submit a pull request with a detailed description of your modifications.

# License Information
Metalibraries is dedicated to the public domain under the Unlicense. You are free to use, modify, and distribute the package without any restrictions.

# Resources
Documentation: Detailed usage instructions and examples are available in the documentation.
Community: Join discussions and get help on the project’s discussion board.
MagicFeeedback 0.0.2
SDK for MagicFeedback API
Requires Python: >=3.8

### MagicFeedback SDK

**A Python SDK for interacting with the MagicFeedback API**

**Installation**

Bash

```
pip install MagicFeeedback

```

Use code [with caution.](/faq#coding)

**Usage**

Python

```
from your_package import MagicFeedbackClient

# Create a MagicFeedbackClient instance
client = MagicFeedbackClient('email', 'password')

# Create a new feedback item
feedback_data = {
    "name": "Test Feedback",
    "type": "DOCUMENT",
    # ... other required fields
}
response = client.create_feedback(feedback_data)

# Print the response
print(response)

```

**API Reference**

- **`create_feedback(feedback)`:** Creates a new feedback item.
- **`get_feedback(feedback_id)`:** Retrieves a specific feedback item.
- **`update_feedback(feedback_id, feedback)`:** Updates a specific feedback item.
- **`delete_feedback(feedback_id)`:** Deletes a specific feedback item.

**Additional Information**

- **Authentication:** The SDK requires an user / password for authentication. You can obtain from the MagicFeedback platform.
- **Error Handling:** The SDK handles common API errors and raises appropriate exceptions.
- **Customizations:** You can customize the SDK to fit your specific needs by extending the `MagicFeedbackClient` class or creating additional helper functions.

**License**

This project is licensed under the MIT License.

**Contact**

For any questions or support, please contact farias@magicfeedback.io.
rstms-nbctl 0.0.9
Top-level package for rstms-nbctl.
Keywords: rstms_nbctl

rstms-nbctl
===========


![Image](https://img.shields.io/github/license/rstms/rstms_nbctl)

![Image](https://img.shields.io/pypi/v/rstms_nbctl.svg)





Netboot Controller


* Free software: BSD license
* Documentation: https://rstms-nbctl.readthedocs.io.



Credits
-------

This package was created with Cookiecutter and `rstms/cookiecutter-python-cli`, a fork of the `audreyr/cookiecutter-pypackage` project template.

[audreyr/cookiecutter](https://github.com/audreyr/cookiecutter)
[audreyr/cookiecutter-pypackage](https://github.com/audreyr/cookiecutter-pypackage)
[rstms/cookiecutter-python-cli](https://github.com/rstms/cookiecutter-python-cli)
krunnerdbusutils 0.1.2
A utility library for interacting with the KRunner API via D-Bus
Requires Python: >=3.10

### krunnerdbusutils

Utilities for writing a KRunner plugin using python.

Usage example:

```py
from krunnerdbusutils import krunner_actions, krunner_match, krunner_run, \
    AbstractRunner, Action, Match, run_event_loop


class Runner(AbstractRunner):
    def __init__(self):
        super().__init__("net.fancyplugin2", "/fancyplugin")

    @krunner_match
    def Match(self, query: str):
        matches = []
        if query == "hello":
            match = Match() # Or utilize keyword constructor
            match.id = "hello_match"
            match.text = "Hello There!"
            match.subtext = "Example"
            match.icon = "planetkde"
            matches.append(match)
        return matches

    @krunner_actions
    def Actions(self):
        return [Action(id="id", text="Action Tooltip", icon="planetkde")]

    @krunner_run
    def Run(self, data: str, action_id: str):
        print(data, action_id)


if __name__ == "__main__":
    run_event_loop(Runner)
```
rime 2.2.1
An automation tool for programming contest organizers

Rime
====

![status](https://travis-ci.org/icpc-jag/rime.svg?branch=master)

Rime is a tool for programming contest organizers to automate usual, boring and error-prone process of problem set preparation.
It supports various programming contest styles like ACM-ICPC, TopCoder, etc. by plugins.

Detailed documentations (in Japanese) are found at documentation site:

https://rime.readthedocs.io/ja/latest/


Cheat sheet
-----------

#### Install Rime

```
$ pip install rime
```

#### Upgrade Rime

```
$ pip install -U rime
```

#### Uninstall Rime

```
$ pip uninstall rime
```

#### Initialize a project

```
$ rime_init --git/--mercurial
```

#### Add a problem

```
$ rime add . problem <problem_dir_name>
```

#### Add a solution

```
$ rime add <parent_problem_dir_name> solution <solution_dir_name>
```

#### Add a testset

```
$ rime add <parent_problem_dir_name> testset <testset_dir_name>
```

#### Build a target (project/problem/solution/testset)

```
$ rime build <target_path> -j <#workers>
```

#### Test a target (project/problem/solution/testset)

```
$ rime test <target_path> -C -j <#workers>
```

#### Pack a target for an online judge (project/problem/testset)

```
$ rime pack <target_path>
```

#### Upload a target to an online judge (project/problem/testset)

```
$ rime upload <target_path>
```

#### Submit a target to an online judge (project/problem/solution)

```
$ rime submit <target_path>
```

#### Edit a configuration file (project/problem/solution/testset)

```
$ vi/emacs/nano <target_path>/<PROJECT/PROBLEM/SOLUTION/TESTSET>
```


New features from Rime Plus
---------------------------

* -O2, -std=c++11 as a default
* Faster parallel test
* native testlib.h support
* subtask / partial scoring
* reactive checker (partially support)
* gcj-styled merged test
* additional commands
* pip support
* judge system deployment
* test result cache
* some bug fix
* JS / CSharp / Haskell codes
* etc.


For developers
--------------

#### How to run unit tests

```
$ python setup.py test
```
slashr 1.0.0
\r Never lose your cursor again!
Keywords: python, terminal

# \R
 A module for printing messages using /r

## Installation
```bash
pip install slashr
```

## Usage

### Using with
```python
from slashr import SlashR

with SlashR() as sr:
    for i in range(10):
        sr.print(i)
```

### Using object
```python
from slashr import SlashR

sr = SlashR()

sr.init()

for i in range(10):
    sr.print(i)

sr.exit()  # Optional if you want to stop slashr entirely

```
github: https://github.com/JustRedTTG/slashr
aa-ravworks-exporter 0.5.1
Ravworks config exporter for AllianceAuth
Requires Python: ~=3.8
Keywords: allianceauth, ravworks, allianceauth_ravworks, ravworks_exporter, ravworks_config, eveonline

# AllianceAuth Ravworks Exporter

This is a plugin for [AllianceAuth](https://gitlab.com/allianceauth/allianceauth) that exports ESI data to a config file for [Ravworks](https://ravworks.com/).

## Prerequisites

This plugin requires a working AllianceAuth installation with v3 as a minimum version. See the [AllianceAuth installation instructions](https://allianceauth.readthedocs.io/en/latest/installation/index.html) for more information.

Data from ESI are not directly fetched by this application, instead it relies on other AllianceAuth plugins. Currently the following plugins are supported:

Skills:

- [MemberAudit](https://apps.allianceauth.org/apps/detail/aa-memberaudit)
- [CorpTools](https://apps.allianceauth.org/apps/detail/allianceauth-corptools)

Structures:

- [aa-structures](https://apps.allianceauth.org/apps/detail/aa-structures)
- [CorpTools](https://apps.allianceauth.org/apps/detail/allianceauth-corptools)

If there are multiple plugins for the same functionality, only 1 is needed. If no plugin is installed, that functionality will be unavailable.

## Installation

1. Install the package with pip:

    ```bash
    pip install aa-ravworks-exporter
    ```

2. Add `'ravworks_exporter',` to your `INSTALLED_APPS` in `local.py`

## Basic usage

1. Download the config file from Ravworks website. This apps doesn't directly create the config files but rather update existing ones with data from ESI.
2. Use it in the form in this plugin page on AllianceAuth.
3. Download the update config file and use it on Ravworks website.
disunity 0.1.17
Python framework for Discord interactions using a web server
Requires Python: >=3.10.0

# disunity

Python framework for Discord interactions using a web server

# Installation
`pip install disunity`

# Introduction to Disunity
```python
import disunity

server = disunity.DisunityServer()

if __name__ == '__main__':
    server.run()
```

Using packages
```python
import disunity
import pathlib

server = disunity.DisunityServer()

@server.before_serving
def load_packages():
    for package in [f"{f.parent}.{f.stem}" for f in pathlib.Path("packages").glob("*.py")]:
        server.load_package(package)

if __name__ == '__main__':
    server.run()

```

# Setting up a package

```python
from disunity import package, utils

class FirstPackage(package.Package):
    def __init__(self, app):
        self.app = app

    @package.Package.command('ping')
    async def ping(self, ctx):
        return await ctx.callback("Pong!")

def setup(app):
    app.register_package(FirstPackage(app))

```

# Disclaimer

This will require that you already have hosting service for the server to run on as well as a domain to host the server on. If you have neither of these, an alternative would be to host on Heroku using a web application with Gunicorn. 

# Side note

The server will receive interactions to the `/interactions` endpoint of your server. It will look like this: `https://example.com/interactions`. Once you run the server, put the url with the added interactions endpoint into the `interactions` URL on your app located in the Discord developer portal.