semvec/pypi-packages huggingface dataset:
figcow 1.0.3
Python cowsay that looks like a figlet
License: MIT

# figcow

Python cowsay that looks like a figlet.

No dependencies.

## install

From Pypi:

`pip3 install figcow`

From GitHub:

`pip3 install git+https://github.com/donno2048/figcow`

## Usage

In cmd:

```sh
> figcow Example
 _________________________________________________
/  _____                                 _        \
| | ____|__  __  __ _  _ __ ___   _ __  | |  ___  |
| |  _|  \ \/ / / _` || '_ ` _ \ | '_ \ | | / _ \ |
| | |___  >  < | (_| || | | | | || |_) || ||  __/ |
| |_____|/_/\_\ \__,_||_| |_| |_|| .__/ |_| \___| |
\                                |_|              /
 ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
     \   ^__^
      \  (oo)\_______
         (__)\       )\/\
           ||----w |
           ||     ||
> echo 9 | figcow
 ____________
/   ___      \
|  / _ \     |
| | (_) |    |
|  \__, |    |
|    /_/     |
\            /
 ‾‾‾‾‾‾‾‾‾‾‾‾
     \   ^__^
      \  (oo)\_______
         (__)\       )\/\
            ||----w |
            ||     ||
```

In a script:

```py
>>> from figcow import cow
>>> c = cow("Another example", 20) # The second argument is the maximum width of the text
>>> print(c)
 __________________
/     _            \
|    / \    _ __   |
|   / _ \  | '_ \  |
|  / ___ \ | | | | |
| /_/   \_\|_| |_| |
|                  |
|         _        |
|   ___  | |_      |
|  / _ \ | __|     |
| | (_) || |_      |
|  \___/  \__|     |
|                  |
|  _               |
| | |__    ___     |
| | '_ \  / _ \    |
| | | | ||  __/    |
| |_| |_| \___|    |
|                  |
|                  |
|  _ __      ___   |
| | '__|    / _ \  |
| | |      |  __/  |
| |_|       \___|  |
|                  |
|                  |
| __  __  __ _     |
| \ \/ / / _` |    |
|  >  < | (_| |    |
| /_/\_\ \__,_|    |
|                  |
|                  |
|  _ __ ___        |
| | '_ ` _ \       |
| | | | | | |      |
| |_| |_| |_|      |
|                  |
|         _        |
|  _ __  | |  ___  |
| | '_ \ | | / _ \ |
| | |_) || ||  __/ |
| | .__/ |_| \___| |
| |_|              |
|                  |
|                  |
|                  |
|                  |
|                  |
\                  /
 ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
     \   ^__^
      \  (oo)\_______
         (__)\       )\/\
           ||----w |
           ||     ||
```
PyMathRender 1.0.2
Pretty rendering method for mathematic functions
License: MIT

# PyMathRender

Pretty rendering method for mathematic functions

## Install

From Pypi:

`py -m pip install PyMathRender`

From GitHub:

`py -m pip install git+https://github.com/donno2048/Maths`

## Use

```py
from PyMathRender import main
main("sum([math.cos(3 ** n * x / 1000) / (3 ** n) for n in range(10)])", Text = r"$\sum_{n=0}^\infty\frac{\cos\left(3^nx\right)}{3^n}$ Is continuous but not differentiable in any point", LineColor = "blue", TextColor = "blue", start = 0, end = 10, step = .001, required = ["math"])
```

Or:

```py
from PyMathRender import main
from math import cos, e, sqrt
def fun(x): return sum([cos(3 ** n * x / 1000) / (e ** (sqrt(3 ** n) - 1)) for n in range(10)])
main(fun, Text = r"$\sum_{n=0}^\infty\frac{\cos\left(3^nx\right)}{e^{-1+\sqrt{3^n}}}$ Is smooth but not analytic in any point", LineColor = "red", TextColor = "red", start = 0, end = 10, step = .001)
```

The first argument is the function (`x` is the variable if you use the string method) - It is the only required argument,

`Text` is the additional text,

`LineColor` is the color of the line plotted, either `blue`, `green`, `red`, `cyan`, `magenta`, `yellow`, `black` or `white`,

`TextColor` is the color of the additional text, same colors as LineColor,

`start`, `end` and `step` are the starting and ending points and the size of the steps between them,

`required` is a list of required packages for the function - needed only using the string method.
ippic 0.0.1
Create an image from an IP address
License: MIT

# ippic

ippic is a tool to create an image from an IP address.

```bash
> python3 -m ippic 127.0.0.1
```

This command will produce a `ip.png` file in your current directory. 

The image of the IPv4 localhost address will be:

![localhost ipv4](./docs/localhost_v4.png)

ippic can recognize IPv4 or IPv6 addresses, also in compressed form.

```bash
> python3 -m ippic ::1 

> python3 -m ippic 0000:0000:0000:0000:0000:0000:0000:0001
```

Both commands above will produce the following image:

![localhost ipv4](./docs/localhost_v6.png)

## Other examples

```bash
> python3 -m ippic 2a00:1450:4001:82b::2003
```

![example](./docs/example.png)
unifi-cam-proxy 0.2.0
Unifi NVR-compatible camera proxy
License: MIT
Requires Python: >3.7.0

[![unifi-cam-proxy Discord](https://img.shields.io/discord/937237037466124330?color=0559C9&label=Discord&logo=discord&logoColor=%23FFFFFF&style=for-the-badge)](https://discord.gg/Bxk9uGT6MW)

UniFi Camera Proxy
==================
## About

This enables using non-Ubiquiti cameras within the UniFi Protect ecosystem. This is
particularly useful to use existing RTSP-enabled cameras in the same UI and
mobile app as your other Unifi devices.

Things that work:
* Live streaming
* Full-time recording
* Motion detection with certain cameras
* Smart Detections using [Frigate](https://github.com/blakeblackshear/frigate)

## Documentation

View the documentation at https://unifi-cam-proxy.com

## Donations

If you would like to make a donation to support development, please use [Github Sponsors](https://github.com/sponsors/keshavdv).
gpkron 0.0.1
2D GP fitting using Kronecker product
License: MIT

# gpkron

A simple and fast [2D gaussian process fitting using Kronecker product](https://github.com/HajimeKawahara/gpkron/blob/main/documents/pdf/GP2D.pdf).

## same shape

```python
    from gpkron.gp2d import GP2D, RBF, Matern32
    import numpy as np
    Nx = 128; Ny = 256
    xgrid = np.linspace(0, Nx, Nx)
    ygrid = np.linspace(0, Ny, Ny)
    sigma = 0.2
    Dmat = np.sin(xgrid[:, np.newaxis]/20) * np.sin(ygrid[np.newaxis, :]/20) + \
        np.random.randn(Nx, Ny)*sigma
    Dprer = GP2D(Dmat, RBF, sigma, (20., 20.))
    Dprem = GP2D(Dmat, Matern32, sigma, (40., 40.))
```

![sample](https://user-images.githubusercontent.com/15956904/152613707-75c7843b-605d-4e62-bf04-32ce5bfa3551.png)

## different shape

```python
    from gpkron.gp2d import GP2D, RBF, Matern32
    import numpy as np
    Nx = 16; Ny = 32
    pshape=(64,128)

    xgrid = np.linspace(0, Nx, Nx)
    ygrid = np.linspace(0, Ny, Ny)
    sigma = 0.2
    Dmat = np.sin(xgrid[:, np.newaxis]/4) * np.sin(ygrid[np.newaxis, :]/4) + \
        np.random.randn(Nx, Ny)*sigma
    Dprer = GP2D(Dmat, RBF, sigma, (20., 20.), pshape=pshape)
    Dprem = GP2D(Dmat, Matern32, sigma, (40., 40.), pshape=pshape)
```

![sample](https://user-images.githubusercontent.com/15956904/152614415-678d5994-1ac2-432d-8d2a-40f0dd4519c6.png)