semvec/pypi-packages huggingface dataset:
exploit-sensei 0.1.6
LLM-powered exploitation recommendation tool
Requires Python: >=3.11

# Exploit Sensei

<div style="display: flex;">
  <img src="assets/image.png" alt="Image" height="420px">
  <img src="assets/screenshot.png" alt="Screenshot" height="420px">
</div>

### Tired of Trying Harder? Ask the Sensei.

Exploit Sensei is a LLM-powered exploitation recommendation CLI that shows you the way to penetration testing.  
It is not an automation tool, but enhances your ability!

## Features

- Tells you how to hack anything.
- Reads your penetration testing memo and provides recommendation.
- Levarages OpenRouter's **free** models, so there is **no cost**.

## Prerequisites

- Python version `>=3.11`
- [OpenRouter](https://openrouter.ai/) API key (FREE)

## Installation

```sh
pipx install exploit-sensei
```

## Usage

### 1. Set the OpenRouter API Key

Login the OpenRouter and get the API key, and set it with the command below:

```sh
exploit-sensei set <OPENROUTER_API_KEY>
```

The API key will be stored under `~/.exploit-sensei/` directory.  
Don't worry, **it only uses free models, so there's no cost.**

### 2. Ask the Sensei

There are various ways to ask the sensei for advice.

- **Option 1. Ask with Your Memo**

  A most useful way is to have the sensei read your pentesting notes and give you advice. Assume that during a penetration test you document the process in `memo.txt`. So the command is as below:

  ```sh
  exploit-sensei ask -f memo.txt
  ```

  The format of the memo file is up to you, as the sensei leverages the power of LLM. The sensei reads it and tell you some advices for further exploitation.  
  
  Furthermore, by providing the text (the `-t` option), you can ask for more specific instructions:

  ```sh
  exploit-sensei ask -f memo.txt -t "I want to find admin password on the target website."
  ```

- **Option 2. Ask with Only Text**

  Of course, you can ask the sensei with text only.

  ```sh
  exploit-sensei ask -t "Provide 10 XSS payloads."
  ```

- **Option 3. Ask with Instructions**

  If you do not specify the `-f` or `-t` options, the sensei will ask you for basic information about the target system and then give you advice. This is recommended as a starting point for penetration testing.

  ```sh
  exploit-sensei ask
  ```

### 3. Specify Model

When asking the sensei with `exploit-sensei ask` command, you can choose specified model as below:

```sh
exploit-sensei ask --model "deepseek-r1-zero"
```

To see available models, run `exploit-sensei ask --help` command. 

## Notes

- OpenRouter has a limit of 200 requests per day for free models. See [the documentation](https://openrouter.ai/docs/faq#how-are-rate-limits-calculated).
unit-sphere-a-designs 0.1.0
A package for local search algorithms on unit sphere designs
Requires Python: >=3.6

# Unit Sphere A Designs

A package for computing A Designs over the unit sphere.

## Installation

You can install the package using pip:

```bash
pip install .
```

## Usage

Here is an example of how to use the package:

```python
from unit_sphere_a_designs.local import local_search
import numpy as np

# Example Runs
d = 40
k = 2 * d + 1

# Run local search with a random staring solution
S_LS = local_search(d, k)
alg_val = np.trace(np.linalg.inv(S_LS @ S_LS.T))
print(f'Finished with a value of {float(alg_val):.5f}')


# Run local search with a fixed starting solution. Fix the first and third vectors so they are not replaced by the algortihm.
S_random = np.random.normal(size=(d, k))
S_random /= np.linalg.norm(S_random, axis=0, keepdims=True)
rand_val = np.trace(np.linalg.inv(S_random @ S_random.T))

print(f'Random solution has a value of {float(rand_val):.5f}')

S_LS_random_start = local_search(d, k, S = S_random, fixed_points = [0, 1, 2])
alg_val_rand_start = np.trace(np.linalg.inv(S_LS_random_start @ S_LS_random_start.T))

print(f'Finished with a value of {float(alg_val_rand_start):.5f}')


```

## Running Tests

You can run the tests using pytest:

```bash
pytest tests/
```
classic-sql-storage 0.0.2
Provides primitives for contextual transactions processing with SQLALchemy and base for repository class
Requires Python: >=3.7

# Classic SQL Storage

This package provides contextual transactions processing for SQLAlchemy and 
base for pattern "Repository".

Part of project "Classic".

Usage:

```python
from classic.sql_storage import TransactionContext
from sqlalchemy import create_engine, text


engine = create_engine('sqlite:///')

transaction = TransactionContext(bind=engine)


# As context manager:
with transaction:
    transaction.current_session.execute(
        text('SELECT 1')
    )


# As decorator:
@transaction
def some_work():
    transaction.current_session.execute(
        text('SELECT 1')
    )


# Propagation:
@transaction
def complex_function():
    """Doing complex work with db.
    Session will be commited only after finish of complex_function call.
    TransactionContext will count all calls, and will commit or rollback session
    only in last call.
    """
    some_work()
    some_work()
    some_work()
    
    with transaction:
        transaction.current_session.execute(
            text('SELECT 1')
        )


# Automatic rollback
@transaction
def function_with_error():
    """Changes, made by some_work, will be cancelled after raising error"""
    some_work()
    raise ValueError()


```
autoroblox 1.1.2
AutoRoblox is a library offering tools for automating Roblox-related gameplay.
Requires Python: >=3.6

# AutoRoblox.
**AutoRoblox** is a library offering tools for automating Roblox gameplay.

Currently, it consists of different commands making to easier to automate Roblox gameplay.

## Commands.
### critical_error(text: str)
**Prints a red "Critical Error" message and shuts down the program.**

Example: `critical_error("Critical Error.")`

Output: 🚫 Critical Error. *and shuts down the program.*

### error(text: str) -> int
**Prints a red "Error" message and returns 1.**

Example: `error("Error.")`

Output: 🛑 Error. *and returns 1.*

### warn(text: str) -> int
**Prints a yellow "Warning" message and returns 0.**

Example: `warn("Warning.")`

Output: ⚠ Warning. *and returns 0.*

### info(text: str)
**Prints a blue "Info" message.**

Example: `info("Info.")`

Output: 🛈 Info.

### info_by_username(information: str, username: str)
**Requests information about someone by his username.**

Example: `print(info_by_username("previousUsername", "AutoRobloxProject"))`

Output: []

Example: `print(info_by_username("hasVerifiedBadge", "AutoRobloxProject"))`

Output: False

Example: `print(info_by_username("id", "AutoRobloxProject"))`

Output: 8166253857

Example: `print(info_by_username("name", "AutoRobloxProject"))`

Output: AutoRobloxProject

Example: `print(info_by_username("displayName", "AutoRobloxProject"))`

Output: AutoRobloxProject

### move(direction: str, studs: float)
**Moves the character in the specified direction for specified studs.**

Example 1: `move("forward", 10)`

Output: *Makes the character move forward by 10 studs if the walk speed is default(16).*

Example 2: `move("backward", 10)`

Output: *Makes the character move backward by 10 studs if the walk speed is default(16).*

Example 3: `move("left", 10)`

Output: *Makes the character move to the left by 10 studs if the walk speed is default(16).*

Example 4: `move("right", 10)`

Output: *Makes the character move to the right by 10 studs if the walk speed is default(16).*

### jump()
**Makes the character jump.** (Unless jumps are disabled)

Example: `jump()`

Output: *Jumps if jumps are enabled.*

### camera(rotation: int, sensivity: float = 1.6)
**Makes the camera rotate.**

Example: `camera(180, 1.6)`

Output: *Rotates camera by 180 if the camera sensivity at Roblox settings is 1.6.*

### chat(message: str)
**Sends a message at chat.**

Example: `chat("Hello!")`

Output: *Sends "Hello!" at chat.*

### click(duration: float, x: int, y: int)
**Clicks on the specified coordinates if any. If none, clicks on the current mouse position.**

Example 1: `click()`

Output: *Clicks.*

Example 2: `click(1)`

Output: *Holds the click for 1 second.*

Example 3: `click(1, 1000, 100)`

Output: *Drags mouse to coordinates x:1000 and y:100 and holds the click for 1 second.*

### press(key: str, duration: float)

Example 1: `press("C")`

Output: *Presses [C].*

Example 2: `press("E", 1)`

Output: *Holds [E] for 1 second.*

**Good luck.**