semvec/pypi-packages huggingface dataset:
funkycam 0.0.6
A small package to make funky video, images, and real-time video
Requires Python: >=3.7

# FunkyCam

This is a simple package with one class, Funk, that allows you to recolor images by "luminance" of each pixel and also extract and thicken edges. 
The final product is a cartoon-like version of the original image or video. Like this:

![Image](./photo.png)

and this:

![Alt Text](./funkykillbill.gif)

To install this package just use:

```bash
pip install funkycam
```

Examples are given in the "examples" folder to demonstrate how to use this package with a webcam, image files, and video files. But, to use this class all you need to do is:

```python
import cv2
from funkycam.funkycam import Funk

img = cv2.imread('example.jpg')

funk = Funk()
funky_img = funk.funkify(img)
```

**Note**: The code expects images that are read using cv2 which means they are in BGR format. If you read with other packages, images are often in RGB format. It may still work fine, but the calculations will be incorrect. Thus, the channels will need to be flipped. 
This can be accomplished on an np array with array slicing:

```python
img_flipped = img[:,:,::-1] # flips third dim
```

## Customizing the Output 
To select colors, there are 3 options:
1. Use the seaborn color_palettes or matplotlib colormaps (https://matplotlib.org/stable/tutorials/colors/colormaps.html).
2. Manually input RGB colors in a list of lists. Resolution is 8 bits: 0-255 each color.
3. Specify "random_colors=True".

If you can't find colors you like, I recommend randomly generating colors and recording the colors that look good. The colors are printed every time it runs, but you can also access them from the Funk object with "funk.colors".

You can also specify the block size and blur value for finding edges, and blur value when finding colors. Increasing the block size seems to increase the thickness of the edges. Increasing blur values will reduce detail in the edges and colors, i.e. fewer edges and larger splotches of colors. These values depend a lot on the resolution of the image or video. **NOTE: The block size and blur values must be odd numbers**. 

## Other Notes
The luminance calculation is not real luminance, it is simplified so that it can recolor video in "real-time" (depends on image quality and number of colors chosen). 

Turns out this method is a little bit like "cel-shading", a commonly used shader algorithm.
summarify 0.1.0
Get title and description from a Web page
Requires Python: >=3.8,<4.0

# Summarify

**Summarify** is a small Python library to extract a title and description from a Web page.

```python
import summarify

summary = summarify.from_url("https://github.com/")

print(summary.title)
print(summary.description)
print(summary.picture)
```
Output:
```text
The world's leading software development platform · GitHub
GitHub is where people build software. More than 27 million people use GitHub to discover, fork, and contribute to over 75 million projects.
https://assets-cdn.github.com/images/modules/open_graph/github-octocat.png
```

## Install

    pip3 install summarify

## Usage

```python
import summarify

summary = summarify.from_url("https://...")

# If you already have the HTML:
# summary = summarify.from_html("...")
```

The `Summary` object returned from `summarify.from_url` has the following
attributes:

* `title` (`str` or `None`)
* `description` (`str` or `None`)
* `url` (`str` or `None`): The URL you passed as an argument. If you used
  `summary.from_markup`, it’ll try to guess it from the markup.
* `picture` (`str` or `None`): Picture URL
* `author` (`str` or `None`)
* `publisher` (`str` or `None`)
* `excerpt`: Always `None` for now

You can also export a summary as a `dict` for e.g. JSON serialization:

```python
dict(my_summary)  # -> {"url": "...", "title": "..."}
```

Be aware that only the non-`None` attributes are included in that dictionnary.
monitorio 0.0.6
Monitor I/O
Requires Python: >=3.10,<4.0.0

# Monitor.io

This is just a stub for a future Readme file

Here are some buzz-phrases:

- Minimal monitoring
- textual/rich
- async programming
- asyncssh instead of paramiko
- Configuration as application


## Installation

While you can just clone and use monitor.io, the intended way to use it is via
`pip` or inside a virtual environment.

Install it locally using `pip`:

```sh
[<PYTHON> -m] pip[3] install [--user] [--upgrade] monitorio
```


## Todo

TBD


## Development & Contribution

### Setup

For active development you need to have `poetry` and `pre-commit` installed

```sh
python3 -m pip install --upgrade --user poetry pre-commit
git clone git@projects.om-office.de:frans/monitor.io.git
cd monitor.io
pre-commit install
# if you need a specific version of Python inside your dev environment
poetry env use ~/.pyenv/versions/3.10.4/bin/python3
poetry install
```

### Workflow

* Create/commit changes and check commits via `pre-commit`
* after work is done locally:
  - adapt version in `pyproject.toml`
  - build and check a package
```sh
poetry build && \
twine check dist/* &&
python3 -m pip uninstall -y monitorio && \
python3 -m pip install --user dist/monitorio-$(grep -E "^version.?=" pyproject.toml | cut -d '"' -f 2)-py3-none-any.whl
```
  - check installed package
  - go through review process
  - publish the new package `poetry publish --build`
  - commit new version && push