semvec/pypi-packages huggingface dataset:
whl-nanoradar-conftool 0.0.1
config tool for nanoradar
Requires Python: >3.8

# whl-nanoradar-conftool

## Installation

```bash
pip install whl-nanoradar-conftool
```

## Usage

### scan devices

```bash
whl-nanoradar-conftool --interface socketscan --channel can1 --bitrate 5000 scan
```

it will print the list of devices found on the CAN bus.

```text
Found nano radar devices:
sensor id: 0, conjecture number: 1
{
    "nvm_read_status": 1,
    "nvm_write_status": 0,
    "max_distance_cfg": 20,
    "sensor_id": 0,
    "sort_index": 1,
    "radar_power_cfg": 0,
    "motion_rx_state": 0,
    "send_ext_info_cfg": 0,
    "send_quality_cfg": 0,
    "output_type_cfg": 1,
    "ctrl_relay_cfg": 0,
    "can_baud_rate": 0,
    "rcs_threshold": 0,
    "calibration_enabled": 0
}
```

### config sensor_id

assume that the current sensor ID is `0`, and you want to set it to `1`.

```bash
whl-nanoradar-conftool --interface socketscan --channel can1 --bitrate 5000 \
    config \
    --message_id $((0x200)) \
    --set sensor_id_valid 1 \
    --set sensor_id 1 \
    --set store_in_nvm_valid 1 \
    --set store_nvm 1
```

after running the command, you can check the sensor id by running the `scan`
command again
wsdiff 0.3.2
wsdiff is a tool that produces a syntax-highlighted, self-contained, static HTML file that will show a colored, syntax-highlighted diff of two files or folders without external dependencies or javascript.
Requires Python: >=3.7

# wsdiff

A python script that produces a diff of two files or directories as a single, self-contained HTML file. The resulting
diff works without Javascript and will automatically switch between inline and side-by-side formats depending on
available screen space.

### Installation
```
pip install wsdiff
```

### Usage
```
usage: wsdiff [-h] [-b] [-s SYNTAX_CSS] [-l LEXER] [-L] [-t PAGETITLE]
                    [-o OUTPUT] [--header] [--content]
                    [old] [new]

Given two source files or directories this application creates an html page
that highlights the differences between the two.

positional arguments:
  old                   source file or directory to compare ("before" file)
  new                   source file or directory to compare ("after" file)

options:
  -h, --help            show this help message and exit
  -b, --open            Open output file in a browser
  -s SYNTAX_CSS, --syntax-css SYNTAX_CSS
                        Path to custom Pygments CSS file for code syntax
                        highlighting
  -l LEXER, --lexer LEXER
                        Manually select pygments lexer (default: guess from
                        filename, use -L to list available lexers.)
  -L, --list-lexers     List available lexers for -l/--lexer
  -t PAGETITLE, --pagetitle PAGETITLE
                        Override page title of output HTML file
  -o OUTPUT, --output OUTPUT
                        Name of output file (default: stdout)
  --header              Only output HTML header with stylesheets and stuff,
                        and no diff
  --content             Only output HTML content, without header
```
### Example Output

![ScreenShot](/screenshots/latest.png)
foundpy 0.3.0
Python implementation of Foundry using python web3 module
Requires Python: >=3.8

# foundpy

Foundpy is a Python implementation of a popular toolkit [Foundry](https://github.com/foundry-rs/foundry). It replicates Foundry's core functionality without needing Foundry's installation. Foundpy enables users to use Python's web3 module with similar command style as Foundry. Foundpy is also equipped with extra features that is primarily used in CTF challenges.

```py
from foundpy import *
config.setup(
    rpc_url="http://rpc.url/",
    privkey="0xdeadbeef"
)
setup_addr = "0xE162F3696944255cc2850eb73418D34023884D1E"
cast.send(setup_addr, "solve(bytes)", b"args123")
cast.call(setup_addr, "isSolved()")
```

## Installation

foundpy can be installed using pip:

```sh
pip install foundpy
```

## Usage

### Initialization

foundpy is best used with jupyter notebooks. But it can be used in a python script as well.

First, initialize the configuration with the RPC and your private key:

```py
from foundpy import *
config.setup(
    rpc_url="http://rpc.url/",
    privkey="0xdeadbeef"
)
```

if you want to change the version of the solidity compiler, you can use the `config.change_solc_version()` function:

```py
config.change_solc_version("0.8.13")
```

if you are doing a CTF Challenges and it uses the [TCP1P ParadigmCTF Infra](https://github.com/TCP1P/Paradigmctf-BlockChain-Infra-Extended), you can use the `config.from_tcp1p` function instead of `config.setup`

```py
result = config.from_tcp1p("http://103.178.153.113:30001")
setup = Contract(result["setup_contract"], "Setup.Sol")
```

also if you are playing HackTheBox challenges, you can use the `config.from_htb` function

```py
result = config.from_htb(address="http://94.237.59.180:51929")
setup = Contract(result["setupAddress"], "Setup.Sol")
```

Once you have solved the challenges, simply call the `config.flag()` function

```py
assert setup.call("isSolved")
print(config.flag())
```

### Interacting with Contracts

To interact with a contract, you can either use the `cast` object or instantiate a `Contract` object (source code required).

```py
setup_addr = "0xE162F3696944255cc2850eb73418D34023884D1E"
cast.send(setup_addr, "solve(bytes)", b"args123" value=ether(0.5))
# or
setup = Contract(setup_addr, "Setup.Sol") # or "Setup.Sol:Setup" to specify the class
setup.send("solve", b"args123", value=ether(0.5))
```

### Deploying Contracts

To deploy a contract, you can either use the `forge` object or use the `deploy_contract` function. Simply make sure that the contract's source code is in the same directory as the script. The constructor arguments can be passed by adding them to the function call after the filename.

```py
# This will return an address
attack = forge.create("Attack.sol:Attack", setup_addr, value=ether(1))
# or
# This will return a Contract object, which you can interact with attack.call or attack.send
attack = deploy_contract("Attack.sol", setup.address, value=ether(1)) # or "Attack.Sol:Attack" to specify the class
```

You can check for more examples in the [example](https://github.com/Wrth1/foundpy/tree/main/example) directory.
Qlip.Core 0.1.0
TheStage AI Full stack R&D Framework
Requires Python: >=3.8

# Qlip.Pytorch

Qlip.Pytorch is the quantization and pruning interface for Pytorch DNNs

---
# Install

Optional dependecies are available for Apple and Nvidia deployment as well as for tests.

```bash
pip install ".[apple]"
pip install ".[nvidia]"
pip install ".[tests]"
```

TensorRT may require a manual installation of extra packages.
Extract the installed version and install the missing packages.

```bash
TRTVERSION=`pip show tensorrt | grep 'Version: \K.+' -Po`
pip install tensorrt-cu12-bindings==$TRTVERSION tensorrt-cu12-libs=$TRTVERSION
```

# Dev

Setup dev environment:
### Pre-commit hooks
1. Install pre-commit `pip install pre-commit-hooks`
2. Run `pre-commit install --hook-type pre-commit --hook-type pre-push` in the repository root.
3. (Optional) run `pre-commit run --all-files` manually if needed.
auto-folderize 0.1.0
A simple Python library to organize files into folders by file type
Requires Python: >=3.6

Here’s your polished and professional `README.md` in full **Markdown format** with ✅ emojis, headings, code blocks, and clarity — ready to upload to **GitHub or PyPI**:

---

````markdown
# Auto-Folderize 🗂️

**Auto-Folderize** is a lightweight and easy-to-use Python library that organizes files in a folder into subfolders based on their file extensions. It supports both **default categorization** and **custom rules**. You can even automatically delete empty folders after organizing.

---

## 📦 Installation

```bash
pip install auto-folderize
````

---

## 🚀 Usage

```python
from auto_folderize import organize, clean

# Organize using default rules
organize(r"D:\test_lib")

# Organize using custom rules
custom_rules = {
    "MyPhotos": ["jpg", "jpeg", "webp"],
    "MyText": ["txt", "md"],
    "Backups": ["zip", "rar"]
}
organize(r"D:\test_lib", rules=custom_rules)

# Clean up empty folders after organizing
clean(r"D:\test_lib")
```

---

## 🧠 Features

* ✅ Automatically sorts files into categories like images, documents, videos, etc.
* ✅ Fully customizable rule sets based on your needs
* ✅ Cleans up leftover empty folders after organization
* ✅ Easy to integrate and extend for automation scripts

---

## 📁 Default Rules (if no custom rules provided)

```python
default_rules = {
    "images": ["jpg", "jpeg", "png", "gif", "bmp"],
    "documents": ["pdf", "docx", "doc", "txt", "pptx", "xlsx"],
    "videos": ["mp4", "mov", "avi", "mkv"],
    "audio": ["mp3", "wav", "aac"],
    "archives": ["zip", "rar", "7z", "tar", "gz"],
    "code": ["py", "js", "java", "c", "cpp", "cs", "html", "css", "json"],
}
```

---

## 👤 Author

Made with 💻 by **Sourav Sandilya**
📧 Email: `youremail@example.com`
🌐 GitHub: [github.com/yourusername](https://github.com/yourusername)

---

## 📄 License

This project is licensed under the **MIT License** – feel free to use and contribute!

---

## 🌟 Contributions Welcome!

Found a bug or have a cool idea?
Fork the repo, open an issue, or make a pull request! Let's improve folder organization together.

```

---

✅ You can now:

- Save this as `README.md`
- Upload it to GitHub with your code
- It’ll also be used for your PyPI page if you add it in `setup.py`

Would you like a matching `setup.py` or `LICENSE` file too?
```
JoyIT-st7920 1.0.1
Library to use the SBC-LCD128x64 with the Raspberry Pi
Requires Python: >=3.7

# JoyIT_st7920
Library to use the SBC-LCD128x64 with the Raspberry Pi

## Installation
You can install this library from PyPI.
To install it for the current user on your Raspberry Pi, use the following command:
```
pip install JoyIT_st7920
```

## Example
You need to clone this repository on your Raspberry Pi to be able to execute the example code.
```
git clone https://github.com/joy-it/JoyIT_st7920
```
Afterward, you need to move into the directory and activate the virtual environment with the following commands.
```
cd JoyIT_st7920
python -m venv --system-site-packages env
source env/bin/activate
```
Then you can execute the example with the following command.
```
cd examples
python example.py
```