semvec/pypi-packages huggingface dataset:
matrixflow 0.1.5
A rich library with implementations for mathematical matrices and vectors and their operations
Requires Python: >=3.10
Keywords: vector, matrix, math


# Matrixflow

[![Downloads](https://static.pepy.tech/badge/matrixflow)](https://pepy.tech/project/matrixflow)

A rich library with implementations for mathematical **matrices** and **vectors** and their operations

Refer to the documentation over [here](https://matrixflow.readthedocs.io/en/latest/index.html)

## Installation

Python 3.10 or higher is required

```bash
py -m pip install matrixflow
```

or from github

```bash
py -m pip install git+https://github.com/Tom-the-Bomb/matrixflow.git
```

## Examples

```py
from matrixflow import Matrix, Vector

A = Matrix([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
])
print(A.det()) # calculates the determinant
A.transpose()  # transposes `A` in place

u = Vector([1, 2, 3])
v = Vector([4, 5, 6])
print(u * v)   # calculates the dot product
```

Further examples can be found over at the documentation [here](https://matrixflow.readthedocs.io/en/latest/examples.html)

## Highlight Features

- **Matrices**
    - Basic operations: addition, subtraction, scalar/matrix multiplication and other basic matrix functions
    - Linear transformations
    - determinant
    - Linear system of equations:
        - Gaussian elimination: row echelon & reduced row echelon forms
        - Inverse
    - and many more!

- **Vectors**
    - Basic operations: addition, subtraction, scalar/dot/cross products and other basic vector functions
    - polar/spherical and cartesian conversions
    - projection, rejection
    - and many more!
simple-rtmw 0.1.1
RTMW simple rtmw inference
Requires Python: >=3.13
Keywords: pose estimation, onnx, rtmpose, yolox, computer vision

# Simple RTMW

Multi-person whole-body pose estimation using ONNX models with RTMPose and YOLOX detectors.

## Installation

Install from PyPI:

```bash
pip install simple-rtmw
```

Or install from source:

```bash
git clone https://github.com/anath2/simple-rtmw
cd simple-rtmw
pip install .
```

## Quick Start

```python
import cv2
from simple_rtmw import Wholebody
from simple_rtmw.draw import draw_annotated_image

# Initialize pipeline
model = Wholebody(device="cpu")  # Use "cuda" or "mps" for GPU

# Load image and run inference
image = cv2.imread("image.jpg")
keypoints, scores = model(image)
detection_boxes = model.det_model(image)

# Format and visualize results
keypoints_with_scores = np.concatenate([keypoints, scores[..., np.newaxis]], axis=-1)
pose_results = model.format_result(keypoints_with_scores)

annotated_image = draw_annotated_image(
    image,
    detection_boxes=detection_boxes,
    pose_results=pose_results
)

cv2.imwrite("output.jpg", annotated_image)
```

## Features

- **Easy to use**: No depencencies except OpenCV, ONNX and Numpy
- **Whole-body detection**: 17 body + 68 face + 21 hand + 3 foot keypoints per person
- **Multi-platform**: CPU, CUDA, MPS (Apple Silicon) support
- **Flexible visualization**: Customizable drawing with detection boxes and pose annotations

## Configuration

```python
from simple_rtmw.draw import DrawConfig, DetectionConfig, PoseConfig

# Control what gets drawn
draw_config = DrawConfig(
    draw_detection_boxes=True,
    draw_pose_keypoints=True,
    draw_pose_skeleton=False
)

# Customize appearance
detection_config = DetectionConfig(box_color=(0, 0, 255), box_thickness=3)
pose_config = PoseConfig(keypoint_radius=5, min_score=0.5)

annotated_image = draw_annotated_image(
    image, detection_boxes, pose_results,
    draw_config=draw_config,
    detection_config=detection_config,
    pose_config=pose_config
)
```

## License

Licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE) for details.

## Acknowledgments

- [RTMPose](https://github.com/open-mmlab/mmpose) for pose estimation models
- [YOLOX](https://github.com/Megvii-BaseDetection/YOLOX) for detection models
- [OpenMMLab](https://openmmlab.com/) for pre-trained models and research
tm-visionone 0.1.0
Python SDK for Trend Micro Vision One
Requires Python: >=3.8
Keywords: trendmicro, visionone, xdr, security, sdk, ioc, trend micro

# tm-visionone

A Python client for the [Trend Micro Vision One API v3](https://automation.trendmicro.com/xdr/api-v3/).

This package helps you integrate with Trend Micro Vision One (XDR) services — especially **Suspicious Object List** and **Connectivity health check** APIs — with clean, consistent responses and retry handling.

---

## ✨ Features
- Upload suspicious objects (IOCs: URL, IP, domain, file hashes, email).
- List suspicious objects with filters, ordering, and pagination support.
- Get next page of results using `nextLink`.
- Health check API for connectivity & token validation.
- Handles **rate limiting (429)** and transient errors (**500, 502, 503, 504**) with retries.
- Region-aware (`us`, `eu`, `jp`, `sg`, `au`, `in`).
- Optional logging.

---

## 📦 Installation

### From PyPI (after release):
```bash
pip install tm-visionone
```

### From TestPyPI (for testing):
```bash
pip install -i https://test.pypi.org/simple/ tm-visionone
```

---

## 🚀 Quick Usage

```python
from tm_visionone import VisionOneClient

API_KEY = "YOUR_API_KEY"

client = VisionOneClient(api_key=API_KEY, region="us", enable_logging=True)

# Healthcheck
print(client.healthcheck())
# -> {'success': True, 'data': {'connectivity': True, 'status': 'available', 'message': 'API reachable and token valid'}, 'error': None}

# Upload suspicious objects
objects = [
    {"url": "http://malicious.example", "description": "Test URL", "scanAction": "log", "riskLevel": "high"}
]
print(client.upload_suspicious_objects(objects))
# -> {'success': True, 'data': [{'status': 201}], 'error': None}

# List suspicious objects
result = client.get_suspicious_objects(top=10)
print(result["data"]["items"])  # Paginated results
```

---

## 📖 Advanced Usage

### Pagination
```python
result = client.get_suspicious_objects(top=10)
print(result["data"]["items"])

if "nextLink" in result["data"]:
    next_page = client.get_next_page(result["data"]["nextLink"])
    print(next_page["data"]["items"])
```

### Logging
Enable built-in logging:
```python
client = VisionOneClient(api_key=API_KEY, region="us", enable_logging=True)
```

---

## 🧪 Running Tests

Clone the repo and install dev dependencies:
```bash
git clone https://github.com/saikumargandhi/tm-visionone.git
cd tm-visionone
pip install -r requirements-dev.txt
pytest -s tests/
```

---

## ⚖️ License

This project is licensed under the MIT License.

---

## 🙏 Attribution

- Built by [Sai Kumar Gandhi](https://github.com/saikumargandhi)
- Powered by [Trend Micro Vision One APIs](https://automation.trendmicro.com/xdr/api-v3/)
wzrdbrain 0.2.1
A simple library to generate trick combinations for wizard skating.
Requires Python: >=3.9
Keywords: wizard skating, tricks, random, generator, inline skating

# wzrdbrain

`wzrdbrain` is the engine behind applications that generate random trick combinations for wizard skating. It helps skaters discover new and creative sequences of moves.

If you're a wizard skater, the best way to use this project is through the [**Rocker'd Magic Moves**](https://rockerd.web.app) app!

The app is powered by this library and works on your phone, even offline.

Logic makes magic.

## Contributing

We welcome contributions! `wzrdbrain` is an open-source project, and we encourage the community to help in many ways.

### Want to add a new trick?

This is the most common way for skaters to contribute! If you know a trick that's missing from the generator, you can add it to our list.

To get started, please read our [**contributing guide**](./CONTRIBUTING.md) which will walk you through the process.

### Other ways to contribute

- Report bugs and suggest features
- Improve documentation
- Submit code improvements for the Python or JavaScript libraries

## For developers

This library is available in both Python and JavaScript.

### Python usage

Install the package from PyPI:
```bash
pip install wzrdbrain
```

Use `generate_combo` to get a list of trick dictionaries.
```python
from wzrdbrain import generate_combo

# Generate a combo of 3 tricks and get their names
combo = generate_combo(3)
trick_names = [trick['name'] for trick in combo]
print(trick_names)
# Example output: ['front open gazelle', 'fakie 360', 'back open lion']
```

### JavaScript usage

You can use the ES6 module directly from the JSDelivr CDN.
```javascript
import { generateCombo } from 'https://cdn.jsdelivr.net/gh/nazroll/wzrdbrain/src/wzrdbrain/wzrdbrain.min.js';

// Generate a combo of 3 tricks and get their names
const combo = generateCombo(3);
const trickNames = combo.map(trick => trick.name);
console.log(trickNames);
```

For more examples, see the [usage documentation](./docs/usage.md).

## Credits

Many thanks to the wizard skating community for their valuable feedback and support. Special thanks to:

- Billy Arlew: for being a reliable source of inspiration and as a [domain knowledge expert on the wizard skating tricks dictionary](https://eccentricinline.com/).
- Eelco Soesman: for being a supportive Slightly Rockerd crew and early tester.
- Bas Bavinck: for being the beacon of wizardry with his book and supporting this project.

## License

This project is licensed under the Apache-2.0 Open Source Software License. See the [LICENSE](./LICENSE) file for details.
optima-vis 1.4.2
A visualization tool for neural network optimizers
Requires Python: >=3.13

# Optima Vis

**Optima Vis** is a Python package for visualizing optimization trajectories of PyTorch models in 2D parameter space.  
It provides tools to plot loss surfaces and generate static or animated visualizations of optimizer behavior, either as GIFs or MP4 videos.

## Features

- **LossContourGenerator** – Generates 2D contour plots of the loss surface for models with exactly two trainable parameters.
- **OptimizerPlotGenerator** – Creates static plots of optimization trajectories on top of the loss contours.
- **OptimizerAnimationGenerator** – Generates animated visualizations (GIF/MP4) of the optimizer's path through parameter space.

## Installation

You can install via PyPI (once published) or directly from source:

```bash
# From PyPI
pip install optima-vis

# From source
git clone https://github.com/yourusername/optima-vis.git
cd optima-vis
pip install .
```

## Dependencies:

- Python 3.13+
- PyTorch 2.8+
- Matplotlib 3.10+

## Usage

```python
from torch import nn, tensor
from torch import randn_like
from optima_vis import (
    OptimizerPlotGenerator,
    OptimizerAnimationGenerator,
    LossContourGenerator,
    VideoProperties,
    GifProperties
)

```

### Generate a loss contour

```python
loss_fcn = nn.MSELoss()
X_interval = [[-10, 10], [-10, 10]]
X_1 = X_interval[0][0] + (X_interval[0][1] - X_interval[0][0]) * rand(100, 1)
X_2 = X_interval[1][0] + (X_interval[1][1] - X_interval[1][0]) * rand(100, 1)
X_samples = cat([X_1, X_2], 1)

def y_true_fcn(X: Tensor) -> Tensor:
    return (X @ Tensor([-5, 6.5]).unsqueeze(1))

y_true = y_true_fcn(X_samples)
y_measured = y_true + 2.0 * randn_like(y_true)  # Measurements with noise

model = Linear(in_features=2, out_features=1, bias=False)

# Create contour generator
contour_gen = LossContourGenerator(loss_fcn, X_samples)
fig, ax = contour_gen(model, y_true)
fig.show()
```

### Plot optimization trajectory

```python
optimizer_plot_gen = OptimizerPlotGenerator(loss_fcn)
fig, ax = optimizer_plot_gen(model, X_samples, y_true, loss_data)
fig.show()
```

- `loss_data` is a list of tuples: (`list[Tensor], Tensor`) representing parameters and corresponding loss at each iteration.

### Generate animated visualization

```python
animation_gen = OptimizerAnimationGenerator()

# Export as GIF
export_props = GifProperties(name="training_animation", length=5)
animation_gen(model, X_samples, y_true, loss_fcn, loss_data, export_props)

# Export as MP4 video
export_props = VideoProperties(name="training_video", length=5, format="mp4")
animation_gen(model, X_samples, y_true, loss_fcn, loss_data, export_props)

```

- Displays the optimizer's path on the loss surface.
- Supports both GIF and MP4 export formats.
- Uses matplotlib.animation.FuncAnimation internally.

# Notes

- Only supports models with exactly two trainable parameters.
- For animations, the frame rate is automatically calculated based on the total number of iterations and the desired video length.
- Arrows indicate the direction of parameter updates in the trajectory.
- More examples can be found under `tests` folder.
inceses 1.0
Turkish Phonetic Transcriptor for Python by Enis Tuna
Requires Python: >=3.10

# İnceses - Turkish Phonetic Transcriptor


*  The phonetic transcriptor function was first written for the [İncesöz](https://github.com/enistuna/incesoz_turkish_linguistics_analyzer) project in 2024 and is now being used for its own Python package for easier deployment and usability.
The function was first developed using the **Özgün Koşaner's** lecture notes from the Phonetics class at *Dokuz Eylul University's Linguistics* department.

## Explanation ##
* To use it, simply import the Python package and write the "inceses.phonetic_analysis('')" line of code. 
Finally, put the Turkish word you want to transcript in the quotation marks and run the code

## Installation ##
* To use the Turkish phonetic transciptor, first install the Python package using the pip command.
```
pip install inceses
```

## How to Use ##
```py
import inceses

decipher = inceses.phonetic_analysis('Enis Tuna ile yemeğe mi gittin?')

print(decipher)
>> "[ ɛnis tʰunα ile jɛme•e mi ɟittʰin? ]"
```