semvec/pypi-packages huggingface dataset:
anime-sama-api 0.2.2.post3
Api for anime-sama
Requires Python: >=3.10
Keywords: anime, anime-sama, downloader

This project is archive. I do not have the time to work on it anymore. I may make some small fixes if a breaking issue arises. 

# Anime-Sama API
An API for anime-sama, also provides a CLI to download videos.

I have implemented all the features I care about. This project is now in maintenance mode.

# Installation
Requirements:
- Python 3.10 or higher

You can simply install it with (note that you can use tools like pipx to isolate the installation):
```bash
pip install anime-sama-api[cli]
```
And to run it:
```bash
anime-sama
```

## Configuration
You can customize the config at :
- Linux: `~/.config/anime-sama_cli/config.toml`
- Windows: `%USER%/AppData/Local/anime-sama_cli/config.toml`
- macOS: `~/Library/Application Support/anime-sama_api/config.toml`

# For developers
## Requirements
- git
- [uv](https://docs.astral.sh/uv/#installation)

## Install locally
```bash
git clone https://github.com/Sky-NiniKo/anime-sama_api.git
cd anime-sama_downloader
uv sync --extra cli
```

## Run
```bash
uv run anime-sama
```

## Update
In the `anime_sama` folder:
```bash
git pull
```

## Contribution
I am open to contribution. Please only open a PR for ONE change. AKA, don't do "Various improvements" and explain your motivation behind your improvement ("Various typos fix"/"Cleanup" is fine).
secuscan 1.1.3
A dual-platform static vulnerability scanner for Android and Web applications.
Requires Python: >=3.9

# SecuScan

A dual-platform static vulnerability scanner for **Android** and **Web** applications.

## Features
- **Auto-Detection**: Automatically detects if the project is Android or Web.
- **Web Scanning**: Uses `Bandit` to find security issues in Python code.
- **Android Scanning**: Uses `MobSF` (via Docker) for deep APK analysis.
- **Reporting**: Output to Console (Rich Table), HTML, or JSON.
- **CI/CD Ready**: Exit codes for passing/failing builds based on severity.

## Getting Started

### Option 1: Docker (Easiest)
You can use the pre-built image directly from Docker Hub without installing Python dependencies.

```bash
# Pull the latest image
docker pull secuscan/secuscan:latest

# Run a scan (replace /path/to/project with your target)
docker run --rm -it -v ${PWD}:/src secuscan/secuscan:latest scan /src
```

### Option 2: PyPI (Python Package)
Install directly via pip:

```bash
pip install secuscan
```

### Option 3: Local Installation
If you prefer to run it from source:

```bash
git clone https://github.com/nkuv/SecuScan.git
cd SecuScan
python3 -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate
pip install -e .
```

### Option 4: Build from Source
To build the Docker image locally:

```bash
docker build -f docker/Dockerfile -t secuscan .
docker run --rm -it -v ${PWD}:/src secuscan scan /src
```

## Usage

### Basic Scan
```bash
secuscan scan .
```

### Output Formats
```bash
secuscan scan . --format table          # Pretty table (default via console)
secuscan scan . --format console        # Text list
secuscan scan . --format json --output report.json
secuscan scan . --format html --output report.html
```

### CI/CD Integration
SecuScan will exit with **code 1** if any **HIGH** or **CRITICAL** vulnerabilities are found.

```yaml
steps:
  - name: Security Scan
    uses: docker://secuscan/secuscan:latest
    with:
      args: scan .
```
cognitive-twin 3.0.0
User pattern learning with trajectory-aware DPO training
Requires Python: >=3.10
Keywords: cognitive-twin, dpo, machine-learning, nlp, trajectory-learning, user-modeling

# CognitiveTwin

User pattern learning with trajectory-aware DPO (Direct Preference Optimization) training.

## Overview

CognitiveTwin is a sophisticated system for learning user communication patterns through:

- **Corpus Surgery**: Data cleaning, validation, and quality filtering
- **WORMS**: Trajectory generators for synthetic training data
  - Conversation Worm: Dialogue trajectory generation
  - Repo Worm: Code repository analysis
  - Task Worm: Task execution patterns
  - DPO Generator: Preference pair generation
- **Dataset Building**: Preference pair labeling and export
- **Evaluation Suite**: Comprehensive testing framework

## Installation

```bash
pip install cognitive-twin

# With training dependencies
pip install cognitive-twin[training]
```

## Quick Start

```python
from cognitive_twin.v3 import pipeline, schema
from cognitive_twin.framework import config

# Initialize pipeline
cfg = config.CognitiveTwinConfig(
    model_name="your-base-model",
    output_dir="./output"
)

# Run corpus surgery
pipeline.run_corpus_surgery(cfg)

# Generate training data
pipeline.generate_dpo_pairs(cfg)

# Train
pipeline.train(cfg)
```

## Components

### v3/ - Main Implementation

- `corpus_surgery/` - Data cleaning and validation
- `dataset/` - Dataset generation and labeling
- `eval/` - Evaluation framework
- `generators/` - Batch and DPO generators
- `ingest/` - Data ingestion (Claude, OpenAI, Supabase)
- `worms/` - Trajectory generators
- `pipeline.py` - Main orchestrator
- `schema.py` - Type definitions

### framework/ - Supporting Infrastructure

- `config.py` - Configuration management
- `twin.py` - Core twin abstraction
- `trainer.py` - Training loop

## Documentation

See the `docs/` directory for detailed documentation:

- `00_OVERVIEW.md` - System overview
- `01_CORPUS_SURGERY.md` - Data cleaning pipeline
- `02_REPO_WORM.md` - Repository analysis
- `03_CONVERSATION_WORM.md` - Dialogue generation
- `04_ENHANCER_AGENT.md` - Quality enhancement
- `05_DATASET_BUILDER.md` - Dataset construction
- `06_TRAINING_PIPELINE.md` - Training guide
- `07_EVALUATION_SUITE.md` - Evaluation metrics
- `08_API_INTEGRATION.md` - API usage

## License

MIT
wii-roms-tool 0.6
A tool for automatically downloading wii roms
Requires Python: >=3.8

# Wii-Rom-Downloader

## Description
This tool is made for automatically downloading your favorite roms for
your wii/emulator and naming it to the right id so your real wii will recognize 
it! It also converts rvz formats to wbfs for real hardware!

## Instruction
Just run this command to install the tool or download binaries from releases!
(Make sure you have python installed!)
```shell
pip install wii-roms-tool
```
To start the menu type:
```shell
wii-roms-tool
```

## Providers
In my tool there are currently 2 options:
Romsfun and Vimms Lair!
1. Romsfun: Better option for availability but needs to be converted for real hardware!
2. Vimms Lair: Easier ID finding and has wbfs files! But big games are missing currently!

## ⚠️ Disclaimer
I provide this tool for educational and informational purposes only.
You are solely responsible for how you use it.
Any actions taken using this tool are entirely your own responsibility.
I do not condone or support illegal use.

## Support 
If you need any help you can open an issue or contact me via discord ``Tmaster055``!
certbot-dns-regru 1.1.1
Reg.ru DNS authenticator plugin for Certbot
Requires Python: >=3.4

# certbot-dns-regru
Reg.ru DNS authenticator plugin for Certbot

**English** | [**Русский**](README.ru.md)

An authenticator plugin for [certbot](https://certbot.eff.org/) to support [Let's Encrypt](https://letsencrypt.org/) 
DNS challenges (dns-01) for domains managed by the nameservers of [Reg.ru](https://www.reg.ru).

Huge thanks to @free2er for creating initial version

## Requirements
* certbot (>=0.21.1)

For older Ubuntu distributions check out this PPA: 
[ppa:certbot/certbot](https://launchpad.net/~certbot/+archive/ubuntu/certbot)

## Installation
1. First install the plugin:
   ```
   sudo pip install certbot-dns-regru
   ```

2. Configure it with your Reg.ru Credentials:
   ```
   sudo nano /etc/letsencrypt/regru.ini
   ```
   Add provider configuration. It is strongly advised to use API password and not your regular password (can be set [here](https://www.reg.ru/user/account/settings/api/))
   ```
   dns_regru_username=<USERNAME>
   dns_regru_password=<PASSWORD>
   ```

   If you use reg.ru's service to manage external domains - no need to worry, plugin tries both plain domain and `"servtype":"srv_dns_both"`

3. Make sure the file is only readable by root! Otherwise all your domains might be in danger:
   ```
   sudo chmod 0600 /etc/letsencrypt/regru.ini
   ```

## Usage
Request new certificates via a certbot invocation like this (adjust paths as needed):

Linux:

```
sudo certbot certonly \
   --authenticator dns-regru \
   --dns-regru-credentials /etc/letsencrypt/regru.ini \
   --dns-regru-propagation-seconds 180 \
   -d sub.domain.tld -d '*.wildcard.tld'
```

Windows (PowerShell):

```
certbot certonly \
   --authenticator dns-regru \
   --dns-regru-credentials C:\path\to\regru.ini \
   --dns-regru-propagation-seconds 180 \
   -d sub.domain.tld -d '*.wildcard.tld'
```

- Note that shell might try to resolve wildcard subdomain (`*`), you should put in in parentheses

Renewals will automatically be performed using the same authenticator and credentials by certbot.

See also `certbot --help certbot-dns-regru` for further information.

## SWAG

To use this plugin with [docker-swag](https://github.com/linuxserver/docker-swag) you need to follow their [guide](https://github.com/linuxserver/docker-swag?tab=readme-ov-file#certbot-plugins)

Add the following environment variables to your container:

```
DOCKER_MODS=linuxserver/mods:universal-package-install
INSTALL_PIP_PACKAGES=certbot-dns-regru
```

Then modify `/config/dns-conf/regru.ini` and provide credentials


## Removal
```
   sudo pip uninstall certbot-dns-regru
```