semvec/pypi-packages huggingface dataset:
numODEsolver 1.0.0
Tool that solves ODE's numerically. Written in Python.
Requires Python: >=3.8

# Numerical ODE Solver

This project is a Python implementation for solving ordinary differential equations (ODEs) numerically. The script allows users to choose between two methods: Euler's Method and Runge-Kutta 4th Order Method (RK4), providing a visual representation of the solution.

## Requirements
Python version >= 3.8

Ensure the following Python libraries are installed:

Install it using `pip`:
```bash
pip install numODEsolver
```
## Example
```bash
from numODEsolver import solver
import matplotlib.pyplot as plt #optional for plot

solver = solver()
f = solver.get_function("y") 
x,y = solver.solve_rk4(f,x0=0,y0=1,n=10000,bound=10.1)
print(solver.get_value(x,y,val=10,dec=5))
```
```bash
from numODEsolver import solver

solver = solver()
f = solver.get_function_2order("dy")
x,y,dy = solver.solve_euler_2order(f,x0=0,y0=1,dy0=1,n=10000,bound=5)
print(solver.get_value(x,y,val=3,dec=2))
```

# Version History

-  8.12.2024 - v0.1 -> only 1st order ODE's are solvable, more features coming soon
- 15.12.2024 - v0.2 -> removed plot function
- 26.1.2025 - v0.3 -> included 2nd order methods, see more on GitHub

---
For more documentation take a look at the source code on my GitHub.

You can modify the script to add more methods, adjust default parameters, or change visualization settings.

This project is open-source and free to use. Contributions and suggestions are welcome!

Lukas
zimbabwean-id-number-validator 1.0.2
Zimbabwean ID Number Validator
Requires Python: >=3.6

# Zimbabwean ID Number Validator

The ID numbers issued in Zimbabwe consist of either 11 or 12 alphanumeric characters. Each ID contains one alphabetic letter, while the remaining characters are numeric digits. Various systems may capture ID numbers in different formats, with the most common formats including:
- 082047823Q29  
- 08-2047823-Q-29
- 08-2047823Q29

| ID | Description           |
|------|-----------------------|
| 08   | District Code         |
| 2047823 | 6 or 7 digit sequence |
| Q    | Alphabetic letter     |
| 29   | District Code         |
-----------------------------------------------------------------------------------

This package uses regular expressions to validate the input against the established patterns. It also includes a lookup of District Codes to ensure the correctness of the ID number.
The three possible responses are as follows:
```python
{
    "is_id_number_valid": False,
    "description": "id number must be in one of the formats: (082047823Q29), (08-2047823Q29), or (08-2047823-Q-29)"
},

{
    "is_id_number_valid": False,
    "description": "id number is invalid"
},

{
    "is_id_number_valid": True,
    "description": "id number is valid"
}

```

District Codes used in the validation procedures were acquired from the following [source](https://ntjwg.uwazi.io/entity/seif769joed?file=15512639038111am2iqd21an.pdf&page=9).


## Usage

Install the package using the following command:

```bash
pip install zimbabwean-id-number-validator
```

### Usage In Python

``` python
from zimbabwean_id_number_validator import validator
validation_results = validator.validate_id_number("082047823Q21")
```

## Keywords
**Zimbabwe** **ID Number** **Validator**
checkkar 0.1.0
A simple library to check if a number is 69
Requires Python: >=3.6

# Checkkar

A simple Python library to check if a number is 69.

## Installation

```
pip install checkkar
```

## Usage

```python
from checkkar import is_69

print(is_69(69))  # True
print(is_69(42))  # False
```
quick-in-voice 0.1.2
A simple automated invoice generation package
Requires Python: >=3.6

# QuickInVoice - Automated Invoice Generator

**QuickInVoice** is a Python package designed to simplify invoice generation for businesses and freelancers. It provides an easy-to-use interface to create, manage, and export invoices in PDF format.

[![PyPI](https://img.shields.io/pypi/v/quickinvoice.svg)](https://pypi.org/project/quickinvoice/)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
[![Python Version](https://img.shields.io/pypi/pyversions/quickinvoice.svg)](https://pypi.org/project/quickinvoice/)
[![Downloads](https://img.shields.io/pypi/dm/quickinvoice.svg)](https://pypi.org/project/quickinvoice/)

---

## Features 🚀

- **📄 Generate invoices** with itemized details and tax calculations.
- **💰 Automatic tax calculations** based on specified tax rates.
- **🖨️ Export invoices to PDF** with customizable templates.
- **⚙️ Easy integration** into any Python application.
- **✅ Unit-tested and reliable** for production use.

---
## Installation 📥

Install QuickInVoice via pip:


```bash
pip install quick-in-voice

```
## Example script
```` bash
from quick_in_voice import InvoiceGenerator

# Define invoice items
items = [
    {"description": "Web Design", "quantity": 2, "price": 500},
    {"description": "SEO Services", "quantity": 1, "price": 750}
]

# Create and generate invoice
invoice = InvoiceGenerator(
    client_name="TechCorp Solutions", 
    client_address="123 Innovation Street, Tech City, TC 12345",
    items=items,
    tax_rate=0.1  # 10% tax rate
)

# generate the pdf in your preffered name 
invoice.generate_pdf("client_invoice.pdf")

````
102203058-Vaishnavi-Topsis 0.0.1
TOPSIS Python Package
Requires Python: >=3.6

# TOPSIS Package

This package implements the TOPSIS (Technique for Order Preference by Similarity to Ideal Solution) method for decision-making.

## Installation
```bash
pip install topsis

## To run file :
pyhton topsis.py <input_file_location> "weights" "impacts" <output_file_location.csv>


Where:
<input_file> is the path to the CSV file containing the decision matrix.
<weights> is a comma-separated list of weights for the criteria (e.g., 1,1,1,1).
<impacts> is a comma-separated list of impact directions for the criteria (e.g., +,+,-,- where + indicates a benefit criterion and - indicates a cost criterion).
<output_file> is the path where the results will be saved, including the TOPSIS score and rank for each alternative.
cached-binance-data 0.2.0
A lightweight Python module for downloading Binance futures market data with caching support
Requires Python: >=3.8

# Cached Binance Futures Data Downloader

A lightweight Python module for downloading Binance futures market data with efficient caching support.

## Features

- Download Binance futures data for different timeframes
- Support for custom start and end periods
- Efficient caching mechanism with automatic system document folder integration
- Handles Binance API rate limits automatically
- Supports various timeframes (1m, 3m, 5m, 15m, 30m, 1h, 2h, 4h, 6h, 8h, 12h, 1d, 3d, 1w, 1M)
- Minimal dependencies with pure Python implementation

## Installation

```bash
pip install cached-binance-data
```

## Dependencies

- python-binance>=1.0.16: Core Binance API functionality
- requests>=2.26.0: HTTP requests handling
- python-dateutil>=2.8.2: Date manipulation utilities
- pytest>=7.0.0: Testing framework (development only)

## Quick Start

```python
from cached_binance_data import BinanceDataDownloader

# Initialize downloader (uses system document folder by default)
downloader = BinanceDataDownloader()

# Or specify a custom cache directory
# downloader = BinanceDataDownloader(cache_dir="path/to/cache")

# Download XRPUSDT data for a specific period
data = downloader.download(
    symbol="XRPUSDT",
    timeframe="1m",
    start_time="2024-01-01",
    end_time="2024-01-31"
)

# Data is returned as a list of [timestamp, high, low, open, close, volume]
print(f"Downloaded {len(data)} data points")
```

## Cache Structure

By default, data is cached in your system's document folder under `binance_data/`:
- Windows: `C:/Users/<username>/Documents/binance_data/`
- macOS: `/Users/<username>/Documents/binance_data/`
- Linux: `~/Documents/binance_data/` or `~/binance_data/`

Cache files are stored with the following format:
```
SYMBOL_TIMEFRAME_STARTDATE_ENDDATE.csv
Example: XRPUSDT_1M_20240101_20240131.csv
```

You can specify a custom cache directory when initializing the downloader:
```python
downloader = BinanceDataDownloader(cache_dir="path/to/cache")
```

## Features

- Automatic data chunking for large date ranges
- Smart caching system with system integration
- Handles rate limits gracefully
- Supports all Binance futures trading pairs
- Efficient CSV-based caching for better compatibility

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the LICENSE file for details.
keepa-crawler 1.0.0
A client to crawl Keepa's historical Amazon product data
Requires Python: >=3.7

# keepa_crawler

A Python client for interacting with Keepa's WebSocket API to retrieve historical Amazon product data.

## Installation

Install from PyPI:

```bash
pip install keepa_crawler
```

## Usage

```python
from keepa_crawler import KeepaClient

# Initialize the client
client = KeepaClient()

# Example 1: Retrieve historical prices for a specific ASIN
try:
    data = client.get_historical_prices(asin="B08N5WRWNW")
    print("Historical Prices:", data)
except Exception as e:
    print(f"Error retrieving data: {e}")

# Example 2: Handling multiple ASINs
asins = ["B08N5WRWNW", "B07XJ8C8F5", "B09FGT1JQC"]
for asin in asins:
    try:
        data = client.get_historical_prices(asin=asin)
        print(f"Data for {asin}: {data}")
    except Exception as e:
        print(f"Error retrieving data for {asin}: {e}")

# Example 3: Handling a timeout error
try:
    data = client.get_historical_prices(asin="B08N5WRWNW", timeout=5)
    print("Historical Prices:", data)
except Exception as e:
    print(f"Timeout or other error occurred: {e}")

# Clean up the client
client.close()
```

## Requirements

* Python 3.8 or newer
* Dependencies are installed automatically via `pip`

## License

This project is licensed under the MIT License. See the `LICENSE` file for details.
Topsis-AbhiroopSingh-102213027 1.0.14
A python package for implementing topsis

# Topsis- Abhiroop_Singh-102213027

Assignment(UCS654)<br>
Submitted by: Abhiroop Singh<br>
Roll no: 102213027<br>
Group: 3C14

## Description

This is a python package used to implement TOPSIS(Technique of Order Preference Similarity to the Ideal Solution) for MCDA(Multiple criteria decision analysis)

<br>

## How to use this package:

## Installation

pip install Topsis-AbhiroopSingh-102213027

## Example:

## Sample dataset

|P1|P2|P3|P4|P5|
|---|---|---|---|---|
|0\.84|0\.71|6\.7|42\.1|12\.59|
|0\.91|0\.83|7\.0|31\.7|10\.11|
|0\.79|0\.62|4\.8|46\.7|13\.23|
|0\.78|0\.61|6\.4|42\.4|12\.55|
|0\.94|0\.88|3\.6|62\.2|16\.91|
|0\.88|0\.77|6\.5|51\.5|14\.91|
|0\.66|0\.44|5\.3|48\.9|13\.83|
|0\.93|0\.86|3\.4|37\.0|10\.55|
## Input

### In Command Prompt

Enter filename followed by .csv or .xlsx extension, then enter values of weights separated by commas like "1,1,1,2,2",then enter values of impacts separated by commas like "+,+,-,-,+" without giving space in between comma value, then enter name of file where you want to save output followed by .csv extension

```
python -m Topsis_AbhiroopSingh_102213027 data.xlsx "1,1,1,1,1" "+,-,+,-,+" output.csv
```

## Output

This will be in our Output csv file
|P1|P2|P3|P4|P5|Topsis Score|Rank|
|---|---|---|---|---|---|---|
|0\.84|0\.71|6\.7|42\.1|12\.59|0\.5945517248616172|2|
|0\.91|0\.83|7\.0|31\.7|10\.11|0\.5662461787825045|3|
|0\.79|0\.62|4\.8|46\.7|13\.23|0\.4853941230447056|6|
|0\.78|0\.61|6\.4|42\.4|12\.55|0\.6127758823558636|1|
|0\.94|0\.88|3\.6|62\.2|16\.91|0\.36155091758331526|8|
|0\.88|0\.77|6\.5|51\.5|14\.91|0\.5387640655736284|5|
|0\.66|0\.44|5\.3|48\.9|13\.83|0\.560458620506467|4|
|0\.93|0\.86|3\.4|37\.0|10\.55|0\.38966293040831607|7|




## Published Package on pypi.org

https://pypi.org/project/Topsis-AbhiroopSingh-102213027/
Topsis-LalitSingla-102383006 1.0.14
A python package for implementing topsis

# Topsis-LalitSingla-102383006

Assignment(UCS654)<br>
Submitted by: Lalit Singla<br>
Roll no: 102383006<br>
Group: 3C14

## Description

This is a python package used to implement TOPSIS(Technique of Order Preference Similarity to the Ideal Solution) for MCDA(Multiple criteria decision analysis)

<br>

## How to use this package:

## Installation

pip install Topsis-LalitSingla-102383006

## Example:

## Sample dataset

|P1|P2|P3|P4|P5|
|---|---|---|---|---|
|0\.84|0\.71|6\.7|42\.1|12\.59|
|0\.91|0\.83|7\.0|31\.7|10\.11|
|0\.79|0\.62|4\.8|46\.7|13\.23|
|0\.78|0\.61|6\.4|42\.4|12\.55|
|0\.94|0\.88|3\.6|62\.2|16\.91|
|0\.88|0\.77|6\.5|51\.5|14\.91|
|0\.66|0\.44|5\.3|48\.9|13\.83|
|0\.93|0\.86|3\.4|37\.0|10\.55|
## Input

### In Command Prompt

Enter filename followed by .csv or .xlsx extension, then enter values of weights separated by commas like "1,1,1,2,2",then enter values of impacts separated by commas like "+,+,-,-,+" without giving space in between comma value, then enter name of file where you want to save output followed by .csv extension

```
python -m Topsis_LalitSingla_102383006 data.xlsx "1,1,1,1,1" "+,-,+,-,+" output.csv
```

## Output

This will be in our Output csv file
|P1|P2|P3|P4|P5|Topsis Score|Rank|
|---|---|---|---|---|---|---|
|0\.84|0\.71|6\.7|42\.1|12\.59|0\.5945517248616172|2|
|0\.91|0\.83|7\.0|31\.7|10\.11|0\.5662461787825045|3|
|0\.79|0\.62|4\.8|46\.7|13\.23|0\.4853941230447056|6|
|0\.78|0\.61|6\.4|42\.4|12\.55|0\.6127758823558636|1|
|0\.94|0\.88|3\.6|62\.2|16\.91|0\.36155091758331526|8|
|0\.88|0\.77|6\.5|51\.5|14\.91|0\.5387640655736284|5|
|0\.66|0\.44|5\.3|48\.9|13\.83|0\.560458620506467|4|
|0\.93|0\.86|3\.4|37\.0|10\.55|0\.38966293040831607|7|




## Published Package on pypi.org

https://pypi.org/project/Topsis-LalitSingla-102383006/
Topsis-AnirudhGarg-102203573 1.0.14
A python package for implementing topsis

# Topsis-AnirudhGarg-102203573

## Description

This is a python package used to implement TOPSIS(Technique of Order Preference Similarity to the Ideal Solution) for MCDA(Multiple criteria decision analysis)

<br>

## How to use this package:

## Installation

pip install Topsis-AnirudhGarg-102203573

## Example:

## Sample dataset

|P1|P2|P3|P4|P5|
|---|---|---|---|---|
|0\.84|0\.71|6\.7|42\.1|12\.59|
|0\.91|0\.83|7\.0|31\.7|10\.11|
|0\.79|0\.62|4\.8|46\.7|13\.23|
|0\.78|0\.61|6\.4|42\.4|12\.55|
|0\.94|0\.88|3\.6|62\.2|16\.91|
|0\.88|0\.77|6\.5|51\.5|14\.91|
|0\.66|0\.44|5\.3|48\.9|13\.83|
|0\.93|0\.86|3\.4|37\.0|10\.55|
## Input

### In Command Prompt

Enter filename followed by .csv or .xlsx extension, then enter values of weights separated by commas like "1,1,1,2,2",then enter values of impacts separated by commas like "+,+,-,-,+" without giving space in between comma value, then enter name of file where you want to save output followed by .csv extension

```
python -m Topsis_AnirudhGarg_102203573 data.xlsx "1,1,1,1,1" "+,-,+,-,+" output.csv
```

## Output

This will be in our Output csv file
|P1|P2|P3|P4|P5|Topsis Score|Rank|
|---|---|---|---|---|---|---|
|0\.84|0\.71|6\.7|42\.1|12\.59|0\.5945517248616172|2|
|0\.91|0\.83|7\.0|31\.7|10\.11|0\.5662461787825045|3|
|0\.79|0\.62|4\.8|46\.7|13\.23|0\.4853941230447056|6|
|0\.78|0\.61|6\.4|42\.4|12\.55|0\.6127758823558636|1|
|0\.94|0\.88|3\.6|62\.2|16\.91|0\.36155091758331526|8|
|0\.88|0\.77|6\.5|51\.5|14\.91|0\.5387640655736284|5|
|0\.66|0\.44|5\.3|48\.9|13\.83|0\.560458620506467|4|
|0\.93|0\.86|3\.4|37\.0|10\.55|0\.38966293040831607|7|




## Published Package on pypi.org

https://pypi.org/project/Topsis-AnirudhGarg-102203573/
vsscunet 2.0.0
SCUNet function for VapourSynth
Requires Python: >=3.10
Keywords: PyTorch, SCUNet, TensorRT, VapourSynth

# SCUNet
Practical Blind Denoising via Swin-Conv-UNet and Data Synthesis, based on https://github.com/cszn/SCUNet.


## Dependencies
- [PyTorch](https://pytorch.org/get-started/) 2.6.0.dev or later
- [VapourSynth](http://www.vapoursynth.com/) R66 or later

`trt` requires additional packages:
- [TensorRT](https://developer.nvidia.com/tensorrt) 10.4.0 or later
- [Torch-TensorRT](https://pytorch.org/TensorRT/) 2.6.0.dev or later

To install the latest nightly build of PyTorch and Torch-TensorRT, run:
```
pip install -U packaging setuptools wheel
pip install --pre -U torch torchvision --index-url https://download.pytorch.org/whl/nightly/cu126
pip install --no-deps --pre -U torch_tensorrt --index-url https://download.pytorch.org/whl/nightly/cu126
pip install -U tensorrt --extra-index-url https://pypi.nvidia.com
```


## Installation
```
pip install -U vsscunet
```

If you want to download all models at once, run `python -m vsscunet`. If you prefer to only download the model you
specified at first run, set `auto_download=True` in `scunet()`.


## Usage
```python
from vsscunet import scunet

ret = scunet(clip)
```

See `__init__.py` for the description of the parameters.
PyPIxz 1.2.0
PyPIxz is a simple, modern, and easy-to-use solution for managing your Python dependencies.
Requires Python: >=3.8

# PyPIxz

**PyPIxz** is a simple, modern, and easy-to-use solution for managing your
Python dependencies.

```python
import pypixz

# Install dependencies listed in a requirements.txt file
pypixz.install_requirements("requirements.txt", enable_logging=False)

# Retrieve information from a module.
result = pypixz.get_module_info("pypixz", version="1.1.2")
print(result)
```

Output result of `get_module_info` command :

```console
{'name': 'pypixz', 'description': 'PyPIxz is a simple, modern, and easy-to-use
solution for managing your Python dependencies.', 'latest_version': '1.1.2',
'project_url': 'https://pypi.org/project/PyPIxz/', 'pypi_url':
'https://pypi.org/project/PyPIxz/', 'specific_version_exists': True}
```

> [!TIP]
> If you need a much lighter version for specific needs you can use our [LITE version](https://github.com/YourLabXYZ/PyPIxz-LITE).

> [!WARNING]
> We recommend using PyPIxz LITE at the very beginning of your program to
> avoid running into the `ModuleNotFoundError` error.

PyPIxz allows you to easily and simply manage the dependencies necessary for your Python program while maintaining a certain security. It is designed to be compatible with other internal modules such as **logging** for log management while ensuring compatibility with any Python environment from version 3.8.

[![Contributors](https://img.shields.io/github/contributors/yourlabxyz/PyPIxz.svg)](https://github.com/yourlabxyz/PyPIxz/graphs/contributors)
[![Issues](https://img.shields.io/github/issues/yourlabxyz/PyPIxz.svg)](https://github.com/yourlabxyz/PyPIxz/issues)
[![Pull Requests](https://img.shields.io/github/issues-pr/yourlabxyz/PyPIxz.svg)](https://github.com/yourlabxyz/PyPIxz/pulls)
[![Forks](https://img.shields.io/github/forks/yourlabxyz/PyPIxz.svg)](https://github.com/yourlabxyz/PyPIxz/network/members)

---

## Installing PyPIxz and Supported Versions

PyPIxz is available on PyPI:

```console
python -m pip install pypixz
```

PyPIxz officially supports **Python 3.8+** :

> [!CAUTION]
> You can use PyPIxz with a version of Python lower than 3.8, but we do not
> guarantee the compatibility of the program or its updates or security.

---

## Supported Features & Best–Practices

PyPIxz is ready to meet the requirements of managing your dependencies in a
robust and reliable way, for today's needs.

- **Fast Installation**: Manage your dependencies from a `requirements.txt` file.
- **Modularity**: Compatible with other tools and libraries, such as `logging`.
- **Broad Compatibility**: Supports modern Python versions (3.8+).
- **Check Module Information:** Retrieves various information about the
modules you want.

## License

This project is licensed under the
[MIT License](https://github.com/yourlabxyz/PyPIxz/blob/master/LICENSE). See
the license file for more details.

---
Topsis-Kunal-102216002 4.0.1
A Python package to perform TOPSIS analysis
Requires Python: >=3.6


# Topsis-Kunal-102216002

A Python package for **TOPSIS (Technique for Order of Preference by Similarity to Ideal Solution)** analysis.  
This tool evaluates and ranks alternatives based on multiple criteria, considering their relative closeness to an ideal solution.

## Installation

Use the package manager pip to install Topsis-Kunal-102216002.

```bash
  pip install Topsis-Kunal-102216002
```
    
## Usage
Enter csv filename followed by .csv extentsion, then enter the weights vector with vector values separated by commas, then enter the impacts vector with comma separated signs (+,-) followed by the name of output.csv file where you want to store the the output file.
```javascript
topsis sample.csv "1,1,1,1" "+,-,+,+" output.csv
```
To view usage help, use
```javascript
topsis /h
```

## Example
#### sample.csv

A csv file showing data for different mobile handsets having varying features.

| Attribute | Price | Storage | Camera | Looks |
|-----------|-------|---------|--------|-------|
| M1        | 250   | 16      | 12     | 5     |
| M2        | 200   | 16      | 8      | 3     |
| M3        | 300   | 32      | 16     | 4     |
| M4        | 275   | 32      | 8      | 4     |
| M5        | 225   | 16      | 16     | 2     |

weights vector = [ 0.25,0.25,0.25,0.25 ]

impacts vector = [ -,+,+,+]

## Input

```bash
topsis sample.csv "0.25,0.25,0.25,0.25" "+,+,-,+" output.csv
```

## Output

| Attribute | Price | Storage | Camera | Looks | Topsis Score   | Rank |
|-----------|-------|---------|--------|-------|----------------|------|
| M1        | 250   | 16      | 12     | 5     | 0.534276857    | 3    |
| M2        | 200   | 16      | 8      | 3     | 0.308367769    | 5    |
| M3        | 300   | 32      | 16     | 4     | 0.691632231    | 1    |
| M4        | 275   | 32      | 8      | 4     | 0.534736584    | 2    |
| M5        | 225   | 16      | 16     | 2     | 0.401046122    | 4    |


## Other notes
- The first column and first row are removed by the library before processing to eliminate indices and headers. Ensure that the CSV follows the format shown in `sample.csv`.
- Ensure the CSV does not contain categorical values.


## License

[MIT](https://www.mit.edu)
langflow-install 0.1.1
Simple langflow installer powered by uv
Requires Python: >=3.12

## langflow-install

A simple installer that uses `uv` to install [langflow](langflow.org). 

with pipx:

    pipx run langflow_install

or with pip run:

    python -m pip install langflow-install
    langflow-install

with uvx

    uvx langflow_install


Then you can run `langflow run`

This project was heavily inspired by `aider-install`.
pcbnewTransition 0.5.0
Library that allows you to support both, KiCAD 5 and KiCAD 6 in your plugins
Requires Python: >3.7

# Pcbnew Transition

This library allows you to easily support KiCAD 8, 7 and 6 in your KiCAD
plugins. It basically monkeypatches KiCAD Python module, so it matches KiCAD 8
API.
## Usage

Instead of:

```python
import pcbnew
from pcbnew import EDA_ANGLE
```

Use:

```python
from pcbnewTransition import pcbnew
from pcbnewTransition.pcbnew import EDA_ANGLE
```

And then, use the API for KiCAD 8. In case you need to distinguish the versions,
you can:

```python
from pcbnewTransition import KICAD_VERSION, isV6

if isV6():
    # something...
```
ejni 0.1.2
Add your description here
Requires Python: >=3.8

# ejni

ejni 是 extract JNI 的简称， 基于 [evilpan/jni_helper](https://github.com/evilpan/jni_helper/blob/master/extract_jni.py) 修改。

## 功能

将 Dex 中的 native 方法，全部提取出来，转成 JNI 函数签名，以便在 Ghidra 等工具进行自动化处理 JNI 函数。

## 为什么

- 移除 androguard 库，减少依赖。
- 发布到 pypi，方便使用。

## 安装

以下任意一种方式都可以：

```sh
pip install ejni
pipx install ejni
rye install ejni
```

## 使用

```sh
ejni demo.apk -o demo_jni.json
```

之后，利用 [evilpan/jni_helper](https://github.com/evilpan/jni_helper/) 提供的插件，进行处理即可。
randip 0.1.0
Random IP generator
Requires Python: >=3.10

# random IP generator v0.1
- IPv4: support
    1. random IPv4
    2. XXX formatting
- IPv6: support
    1. random IPv6

피코가 좋아하는 랜덤 게임. 무슨 게임. 게임 스타트.
아이피 아이피 아이피 아이피 아이피 아이피 A Ahaha