semvec/pypi-packages huggingface dataset:
kamera 0.4.2
Effortless real-time webcam streaming and video processing
Requires Python: >=3.7

# Kamera

**Kamera** makes real-time webcam streaming effortless. The only thing you need to know is:

```bash
pip install kamera
```

```bash
kamera
```

And voilà! Your webcam is live and streaming at `http://localhost:4141`. No setup headaches, just instant results.

## Demo

![dog](https://github.com/cobanov/kamera/raw/main/assets/example.png)

## Features

- Stream live video from your webcam directly to a web interface.
- Adjust settings dynamically, including:
  - Brightness
  - Rotation
  - Grayscale
  - Mirroring
  - Filters (e.g., Sepia, Blur, Edge Detection)
- Easy-to-use API built with FastAPI.
- Real-time video processing using OpenCV.

## API Endpoints

- **GET /video_feed**: Stream the live video feed.
- **POST /settings**: Update video processing settings dynamically.

### Settings Example

Use the `/settings` endpoint to update the following parameters:

- `rotate`: Rotation angle (0, 90, 180, 270).
- `brightness`: Adjust the frame brightness (default: 1.0).
- `grayscale`: Toggle grayscale mode (default: False).
- `mirror`: Mirror the video feed (default: False).
- `filter_name`: Apply a filter (`none`, `sepia`, `blur`, `edges`).

Example request (using `curl`):

```bash
curl -X POST http://localhost:4141/settings \
  -d "rotate=90" \
  -d "brightness=1.5" \
  -d "grayscale=true" \
  -d "filter_name=sepia"
```

## License

This project is licensed under the MIT License.

---

Crafted with ❤️ by Mert Cobanov
diffeq-solver-tk 0.0.12
Tkinter application for solving differential equations.
Requires Python: >=3.10

# diff-eq-solver

![Tests](https://github.com/joeyshi12/diff-eq-solver/actions/workflows/tests.yml/badge.svg)
![PyPI](https://img.shields.io/pypi/v/diffeq-solver-tk)

An application that uses the finite difference method to solve various types of differential equations, such as the
heat equation and wave equation. The solution is written to a table in an Excel file, and the solution is visually
displayed on a plot. For time dependent PDEs, the plot is animated.

<p align="center">
  <img src="https://raw.githubusercontent.com/joeyshi12/diff-eq-solver/master/snapshots/heat_eq_demo.png" style="width: 400px;">
  <img src="https://raw.githubusercontent.com/joeyshi12/diff-eq-solver/master/snapshots/wave_eq_demo.png" style="width: 400px;">
  <img src="https://raw.githubusercontent.com/joeyshi12/diff-eq-solver/master/snapshots/wave_eq_demo.gif" style="width: 400px;">
</p>

## Installation
```
pip3 install diffeq-solver-tk
```

## Usage
The GUI can be started with `detk`. Once you open the solver, choose a differential equation type through the
navigation bar above and enter the parameters for your equation. Clicking "Solve" will run the solving algorithm
for your equation and generate a static plot in the right window. After a solution is prepared, you can export the
solution as an xlsx file by clicking "Export". For partial differential equation types, you can play an animation
in the right window by clicking "Play" and switch back to the static plot by clicking "Show Plot".

diffeq-solver-tk can also be used in the command-line by running `detk-cli <diff-eq-type> <infile> <outfile>`.
Examples of valid `<infile>` files are provided in `tests/queries`. Run `detk-cli -h` for more info.

## Dev Wiki
- [First order differential equations](https://github.com/joeyshi12/diff-eq-solver/wiki/First-Order-Differential-Equation-Solving-Algorithm)
- [Second order differential equations](https://github.com/joeyshi12/diff-eq-solver/wiki/Second-Order-Differential-Equation-Solving-Algorithm)
- [One-dimensional Heat Equation](https://github.com/joeyshi12/diff-eq-solver/wiki/One-dimensional-Heat-Equation-Solving-Algorithm)
- [One-dimensional Wave Equation](https://github.com/joeyshi12/diff-eq-solver/wiki/One-dimensional-Wave-Equation-Solving-Algorithm)
libclamav-py 0.2.0
libclamav-py is a Python library that provides a seamless interface to the ClamAV antivirus engine via libClamAV. This wrapper directly calls the C API of Libclamav
Requires Python: <4.0,>=3.12

# libclamav-py

[![test](https://github.com/tkasuz/libclamav-py/actions/workflows/test.yaml/badge.svg)](https://github.com/tkasuz/libclamav-py/actions/workflows/test.yaml)
![PyPI](https://img.shields.io/pypi/v/PACKAGE?label=pypi%20libclamav-py)
![PyPI - Downloads](https://img.shields.io/pypi/dm/libclamav-py)

libclamav-py is a Python wrapper for the ClamAV library, providing an interface to ClamAV's virus scanning capabilities.

## Features
- Directly invokes the C API of libclamav, so the clamd daemon doesn't need to be running on your machine
- Lambda Layer which libclamav is binded (TODO)

## Installation

To install libclamav-py, use pip:

```sh
pip install libclamav-py
```

## Usage

Here is a basic example of how to use libclamav-py:

```python
from libclamav_py.clamav import Client

# Initialize the libclamav engine with the default setting
client = Client(libclamav_path="/lib/libclamav.so")

# Or libclamav client can be initialized from clamd.conf
client = Client.from_clamd_conf(clamd_conf_path="/etc/clamd.conf", libclamav_path="/lib/libclamav.so")
```

```python
# Load virus definitions
client.load_db()

# Compile engine
client.compile_engine()

# Scan a file
result = client.scan_file('/path/to/file')
if result:
    print(f"Virus detected: {result}")
else:
    print("No virus detected")
```

## License
This project is licensed under the GPL-2.0 License. See the [LICENSE](LICENSE) file for details.

## Acknowledgements

- [ClamAV](https://www.clamav.net/) for the virus scanning engine
ez-fuzzbenedict 0.1.0
A Python Benedict extension to include fuzzy logic for matching keys (using keypaths)
Requires Python: >=3.10

# FuzzBenedict

A Python Benedict extension to include fuzzy logic for matching keys (using keypaths)

## Installation

```bash
pip install fuzzbenedict
```

## Usage

```python
from fuzzbenedict import FuzzBenedict

data = {
    "person": {
        "name": "John Doe",
        "address": {
            "city": "New York",
            "zipcode": 10001
        }
    }
}

fb = FuzzBenedict(data)
print(fb.fuzzy_get("pers.name"))  # Test fuzzy match
```

You can also set a custom threshold for the fuzzy matching:

```python
fb = FuzzBenedict(data, threshold=90)
print(fb.fuzzy_get("pers.name"))  # Test fuzzy match
```

Or adjust the threshold at runtime:

```python
fb = FuzzBenedict(data)
fb.threshold=90
print(fb.fuzzy_get("pers.name"))  # Test fuzzy match
```


And set a default factory if the key is not found/matched:

```python
fb = FuzzBenedict(data, default_factory=lambda: None)
print(fb.fuzzy_get("pers.name"))  # Test fuzzy match
```

You can also adjust the behavior of the class:

```python
FuzzBenedict.Config.fuzzy_in_getitem = True
print(fb["pers.name"])
```

## License

MIT

## Author

Christophe Druet - [christophe@stoachup.com](mailto:christophe@stoachup.com)

## Copyright

Copyright (c) 2024 Stoachup SRL - All rights reserved.