semvec/pypi-packages huggingface dataset:
ktkkt-downloader 1.0.1
downloader for videos on ktkkt.cc
Requires Python: >=3.8

# ktkkt-downloader #

## About ##
A tool to get anime from [ktkkt.cc](https://www.ktkkt.cc/) with CLI (Command Line Interface) and GUI (Graphical User Interface).
It currently supports to download one single episode / all episodes in a series.

## Prerequisites ##
To running this tool, please make sure the following prerequisites are ready:
* [FFmpeg](https://www.ffmpeg.org/)

## Usage (Package) ##
```
from ktkkt_downloader import KtkktDownloader
downloader = KtkktDownloader(args.directory)

# download all episodes in a series (e.g. 鬼滅之刃粵語)
series_url = "https://www.ktkkt.cc/movie/index15170.html"
downloader.download_series(series_url)

# download single episode (e.g. 鬼滅之刃粵語 EP.01)
episode_url = "https://www.ktkkt.cc/play/15170-0-0.html"
downloader.download_episode(episode_url)
```

## Usage (Standalone) ##
Before running the application, required packages need to be installed by following command:
```
$ python -m pip install -r requirements.txt
```

### CLI (Command Line Interface) ###
```
# download single episode
$ python __main__.py -d OUTPUT_DIR -u TARGET_URL

# download all episodes in a series
$ python __main__.py -d OUTPUT_DIR -u TARGET_URL -a
```

#### Example ####
鬼滅之刃粵語,  
series URL: https://www.ktkkt.cc/movie/index15170.html  
episode 1 URL: https://www.ktkkt.cc/play/15170-0-0.html  
```
# download 鬼滅之刃粵語 episode 1 to /home/ktkkt/ by the episode URL
$ python __main__.py -d /home/ktkkt/ -u https://www.ktkkt.cc/play/15170-0-0.html

# download 鬼滅之刃粵語 all episodes to /home/ktkkt/ by the episode URL
$ python __main__.py -d /home/ktkkt/ -u https://www.ktkkt.cc/play/15170-0-0.html -a

# download 鬼滅之刃粵語 all episodes to /home/ktkkt/ by series URL
$ python __main__.py -d /home/ktkkt/ -u https://www.ktkkt.cc/movie/index15170.html -a
```

### GUI (Graphical User Interface) ###
```
# start gui
$ python __main__.py
```
![ktkkt-downloader screenshot](docs/screenshot.png?raw=true "ktkkt-downloader")
Provide the TARGET_URL, OUTPUT_DIR and then click the buttons to download the single episode / all episodes in a series  

## License ##
[GNU GPL v3.0](LICENSE.md)
henon2midi 0.0.1
This application generates midi bifurcation diagrams generated from generated logistic map data.

# henon2midi

This application generates midi output and midi files from Henon map data.

## Installation

- Install from PyPI:
```bash
pip3 install henon2midi
```

## Usage

- For help:
```bash
henon2midi --help
```

- Run with default settings:
```bash
henon2midi
```
This will generate a midi file in the current working directory.

- Sending midi output to a specific device:

```
henon2midi --midi-out-device device_name
```

Where `device_name` is the name of the midi device you want to send the output to. Use a `device name` of 'default' to use the first available device e.g.

```bash
henon2midi --midi-out-device 'device_name'
```

- Enabling midi loopback driver on macOS (e.g. for use with DAWS):
    1. Open 'Audio MIDI Setup.app'
    2. Click 'Window' -> 'Show MIDI Studio'
    3. Double click 'IAC Driver' device
    4. Check 'Device is online' checkbox
    5. Click 'Apply'
    6. Make sure 'IAC Driver' enabled as a midi input device in your DAW

## Installation from source

- Prerequisites:
    - Python 3
    - pip

Make sure pip is up to date:
```bash
python3 -m pip install --upgrade pip
```

- Install package from source code:
```bash
pip install .
```

- Now you can run the application from the command line e.g.
```bash
henon2midi --version
```

## Development

- Pre-requisites:
    - Python 3
    - pip
    - virtualenv

- Use the Makefile for local development:

1. Activate a virtual environment:
```bash
make virtualenv
```

2. Activate the virtual environment (not strictly necessary, if using the Makefile only):
```bash
source venv/bin/activate
```

3. Install dependencies:
```bash
make install
```

Then you can:

- Run the application:
```bash
make run
```
Extra arguments can be passed by providing EXTRA_ARGS variable e.g.
```bash
make run EXTRA_ARGS="--help"
```

- Run tests:
```bash
make test
```

- Run linter:
```bash
make lint
```
`make fmt` can be used to automatically fix some linting errors.

- Other useful make targets are provided too, see the Makefile for details. Or run `make`/`make help`
compute-api-client 0.0.3
A client library for accessing Compute API
Requires Python: >=3.7,<4.0

# compute-api-client
A client library for accessing Compute API

## Usage
First, create a client. Since Compute requires authentication, use `AuthenticatedClient` class

```python
from compute_api_client import AuthenticatedClient

client = AuthenticatedClient(base_url="http://compute-api:8000", token="SuperSecretToken")
```

Now we call Compute and get the list of Plugins:

```python
from compute_api_client.models import Plugin
from compute_api_client.api.plugin_controller import plugin_controller_find
from compute_api_client.types import Response

response: Response[MyDataModel] = get_my_data_model.sync_detailed(client=client)
```

Or do the same thing with an async version:

```python
from compute_api_client.models import Plugin
from compute_api_client.api.plugin_controller import plugin_controller_find
from compute_api_client.types import Response

response: Response[MyDataModel] = await get_my_data_model.sync_detailed(client=client)
```

There are more settings on the generated `Client` class which let you control more runtime behavior, check out the docstring on that class for more info.

Things to know:
1. Every path/method combo becomes a Python module with four functions:
    1. `sync`: Blocking request that returns parsed data (if successful) or `None`
    1. `sync_detailed`: Blocking request that always returns a `Request`, optionally with `parsed` set if the request was successful.
    1. `asyncio`: Like `sync` but async instead of blocking
    1. `asyncio_detailed`: Like `sync_detailed` but async instead of blocking

1. All path/query params, and bodies become method arguments.
1. If your endpoint had any tags on it, the first tag will be used as a module name for the function (my_tag above)
1. Any endpoint which did not have a tag will be in `compute_api_client.api.default`

## Building / publishing this Client
This project uses [Poetry](https://python-poetry.org/) to manage dependencies  and packaging.  Here are the basics:
1. Update the metadata in pyproject.toml (e.g. authors, version)
1. If you're using a private repository, configure it with Poetry
    1. `poetry config repositories.<your-repository-name> <url-to-your-repository>`
    1. `poetry config http-basic.<your-repository-name> <username> <password>`
1. Publish the client with `poetry publish --build -r <your-repository-name>` or, if for public PyPI, just `poetry publish --build`

If you want to install this client into another project without publishing it (e.g. for development) then:
1. If that project **is using Poetry**, you can simply do `poetry add <path-to-this-client>` from that project
1. If that project is not using Poetry:
    1. Build a wheel with `poetry build -f wheel`
    1. Install that wheel from the other project `pip install <path-to-wheel>`
saveMZ 1.0.0
It's easy save in Python with Json file
Requires Python: >=3.7

# saveMZ ⚜️

# it's easly save with json file in python 

## install library

```bash
pip install saveMZ
```

## command
```python
import saveMZ

read(file_path,data)
write(file_path,data)

writes(data)
reads(data)
```
server-discovery 0.1.1
Automatically find your server(s) by port on the local network

# server-discovery

Python library for automatically finding your server(s) by port on the local network


## Install

Just do `pip install server-discovery`


## Usage

On the server side start the response mainloop with your chosen ports:
```python
import server_discovery
server_discovery.server_responseloop(7491, 7492)
```

The clients can then search for servers using those same ports, and devices will be returned in a generator as they are found:

```python
import server_discovery
for server in server_discovery.search_for_servers(7491, 7492):
    print(server)
```

The server calls out on all available interfaces and the client gets the relevant address, so this still works when using multiple (virtual) networks (like when in a Docker container).


## What's returned?

Servers are returned as ServerInfo objects (uses [Pydantic](https://docs.pydantic.dev) models) that include the ip address and persistent device id of the server, so the same server can be found even if the device's ip address changes.

You can also pass a device name or the service version as optional info to be sent from the server.

```python
class ServerInfo:
    ip_address: str
    device_id: int
    device_name: Optional[str]
    service_version: Optional[str]
```
google-drive-uploader 0.1.0
This is a simple file uploader to Google Drive
Requires Python: >=3.8

# Google Drive Updater

[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/Mai0313/Google-Drive-Uploader/master.svg)](https://results.pre-commit.ci/latest/github/Mai0313/Google-Drive-Uploader/master)

### This is a simple program that can help you upload your file to Google Drive

#### In the pass, uploading files to Google Drive was a little bit annoying, so I made this program to help me upload my file to Google Drive.

#### The point is making it easier to upload files to Google Drive.

## The Main Feature

- `upload_file`: Upload your file to Google Drive, EXCEPT `folder`
  - `target`: This is a list you wanna upload
  - `target_folder_id`: This is the target folder you wanna save on Google Drive
    ```python
    upload_file(target, target_folder_id)
    ```
- `create_folder`: Create a folder and it will return a file id
  - `foldername`: This is a list you wanna upload
  - `target_folder_id`: This is the target folder you wanna save on Google Drive
    ```python
    create_folder(foldername, target_folder_id)
    ```

## How to get credentials

1. Enable Google Drive API
2. Create your own Ouath file called `client_secret.json`
3. Rename `client_secret.json` to `credentials.json`

### Once you run this program, you will see a panel tells you to login

### Just do whatever it tells you to do.

## For more Details, Please Check:

[How to Enable Google Drive API](https://support.google.com/googleapi/answer/6158841?hl=en "link")

[How to Get Your Client Secret](https://support.google.com/cloud/answer/6158849?hl=en "link")
file-uploader 0.1.0
This is a simple file uploader to Google Drive
Requires Python: >=3.8

## The Main Feature

- `upload_file`: Upload your file to Google Drive, EXCEPT `folder`
  - `target`: This is a list you wanna upload
  - `target_folder_id`: This is the target folder you wanna save on Google Drive
    ```python
    upload_file(target, target_folder_id)
    ```
- `create_folder`: Create a folder and it will return a file id
  - `foldername`: This is a list you wanna upload
  - `target_folder_id`: This is the target folder you wanna save on Google Drive
    ```python
    create_folder(foldername, target_folder_id)
    ```

## How to get credentials

1. Enable Google Drive API
2. Create your own Ouath file called `client_secret.json`
3. Rename `client_secret.json` to `credentials.json`

### Once you run this program, you will see a panel tells you to login

### Just do whatever it tells you to do.

## For more Details, Please Check:

[How to Enable Google Drive API](https://support.google.com/googleapi/answer/6158841?hl=en "link")

[How to Get Your Client Secret](https://support.google.com/cloud/answer/6158849?hl=en "link")
dj-beatcloud 2.6.0
DJ Tools is a library for managing a collection of music.
Requires Python: >=3.6
Keywords: DJ Rekordbox spotify reddit aws s3

# DJ Tools
[![image](https://img.shields.io/pypi/v/dj-beatcloud.svg)](https://pypi.org/project/dj-beatcloud/)

Please see the [docs](https://a-rich.github.io/DJ-Tools/) for tutorials, how-to guides, conceptual guides, and references!

# Release Plan
* 2.6.1
    - [ ] [Stability issues with requests to the search endpoint of the Spotify API](https://github.com/a-rich/DJ-Tools/issues/58)
    - [ ] [Make Spotify API calls asynchronous](https://github.com/a-rich/DJ-Tools/issues/38)
* 2.7.0
    - [ ] [Improve Reddit submission title parsing in order to improve precision and recall of Spotify API search results](https://github.com/a-rich/DJ-Tools/issues/59)
    - [ ] [Derive boolean algebra expressions that generate a given playlist](https://github.com/a-rich/DJ-Tools/issues/106)
    - [ ] [Create graphic user interface for djtools](https://github.com/a-rich/DJ-Tools/issues/118)

# Contribution
Please see the [CONTRIBUTING](CONTRIBUTING.md)
atternio 0.2.0
A PoC tool for CWE prioritization according to MITRE CAPEC dictionary.
Requires Python: >=3.9,<4.0

# Introduction

Atternio is a PoC tool powered by [flawfinder](https://github.com/david-a-wheeler/flawfinder) for CWE prioritization according to MITRE CAPEC dictionary.

The tool utilises open source CAPEC data provided in the form of JSON (STIX 2.x) files.

## Algorithm

The tool receives a path to C/C++ sources as an input, which is passed to flawfinder to find CWEs.

Each CWE is searched through CAPEC data to determine attack patterns (CAPEC-IDs) it can used in.

When analyzing CAPEC data, the following metrics are taken into account:

* Severity (`x_capec_severity`);
* Likelihood (`x_capec_likelihood_of_attack`).

An individual CWE can be found in multiple CAPEC-IDs.

For each CWE in CAPEC-ID risk points are calculated using the following formula:

```text
cwe_risk = severity + likelihood
```

Each CAPEC-ID can contain multiple detected CWEs:

```text
capec_risk = sum(cwe_risk)
```

Finally, the total number of risk points:

```text
total_risk = sum(capec_risk)
```

When the risk enumeration is complete, the tool will output 2 tables:

* **CWE Records** - all CWEs detected with their location in provided sources;
* **Prioritized CWE Records** - prioritized CWEs with related CAPECs and percentage of shared risk.

## Usage

```help
$ python3 atternio/ --help
usage: [-h] --source PATH_INPUT [--install-dictionary] [-o OUTPUT] [--results]

Atternio - a PoC tool for CWE prioritization according to MITRE CAPEC dictionary.

optional arguments:
  -h, --help            show this help message and exit
  --source PATH_INPUT   path to file or directory
  --install-dictionary  if CAPEC dictionary is not present, install it
                        automatically
  -o OUTPUT, --output OUTPUT
                        path to output file
  --results             show only RESULTS section
 ```
sklearn-mlmlm 1.0.0a2
A python and sklearn compatible implementation of ML-MLM.
Requires Python: >=3.10,<3.13

.. -*- mode: rst -*-

.. |ReadTheDocs| image:: https://readthedocs.org/projects/scikit-mlmlm/badge/?version=latest
.. _ReadTheDocs: https://scikit-mlmlm.readthedocs.io/en/latest/?badge=latest

scikit-mlmlm - A python and sklearn compatible implementation of ML-MLM.
========================================================================

`scikit-mlmlm` is a Python and scikit-learn compatible implementation of Minimal Learning Machine - Multi Label Classifier, based on the Arxiv paper `Minimal Learning Machine for Multi-Label Learning <https://arxiv.org/abs/2305.05518>`_ and the GitHub repository https://github.com/jookriha/ml-mlm.

`Example Implementation: <https://colab.research.google.com/drive/1g5IpGNUSsZvE_bKCN3vXX8gxIRnjHmxC?usp=sharing>`_

A quick demo can be found in `ml_mlmlm_demo.py` at the root of the project.