semvec/pypi-packages huggingface dataset:
grheat 0.2.1
Green's functions for point, line, and planar heat sources.
License: MIT
Requires Python: >=3.8
Keywords: temperature,heat transfer,Green's function,point source,line source,plane source

grheat
======

by Scott Prahl

.. image:: https://img.shields.io/pypi/v/grheat?color=68CA66
   :target: https://pypi.org/project/grheat/
   :alt: pypi

.. image:: https://img.shields.io/github/v/tag/scottprahl/grheat?label=github&color=68CA66
   :target: https://github.com/scottprahl/grheat
   :alt: github

.. image:: https://img.shields.io/conda/vn/conda-forge/grheat?label=conda&color=68CA66
   :target: https://github.com/conda-forge/grheat-feedstock
   :alt: conda

.. image:: https://zenodo.org/badge/357035523.svg
   :target: https://zenodo.org/badge/latestdoi/357035523
   :alt: zenodo

|

.. image:: https://img.shields.io/github/license/scottprahl/grheat?color=68CA66
   :target: https://github.com/scottprahl/grheat/blob/master/LICENSE.txt
   :alt: License

.. image:: https://github.com/scottprahl/grheat/actions/workflows/test.yaml/badge.svg
   :target: https://github.com/scottprahl/grheat/actions/workflows/test.yaml
   :alt: testing

.. image:: https://readthedocs.org/projects/grheat/badge?color=68CA66
  :target: https://grheat.readthedocs.io
  :alt: docs

.. image:: https://img.shields.io/pypi/dm/grheat?color=68CA66
   :target: https://pypi.org/project/grheat/
   :alt: Downloads

__________

Green's Functions for Heat Transfer
-----------------------------------

`grheat` is a library offering Green's function solutions for heat transfer
problems in various geometries and boundary conditions. This module provides
solutions for point sources, line sources, plane sources, and exponential heating 
in semi-infinite media.

Main Features
-------------
- Green's function solutions for point, line, and plane sources in semi-infinite media.
- Solutions for exponential heating of a semi-infinite absorbing medium.
- Supports different boundary conditions at the surface (z=0): infinite, adiabatic, and zero.
- Accurate and efficient calculations based on mathematical formulations provided in 
  recognized literature (e.g., Carslaw and Jaeger).

Installation
------------

**these don't work yet**

Use ``pip``::

    pip install grheat

or ``conda``::

    conda install -c conda-forge grheat

or use a Jupyter notebook immediately by clicking the Google Colaboratory button below

.. image:: https://colab.research.google.com/assets/colab-badge.svg
  :target: https://colab.research.google.com/github/scottprahl/grheat/blob/master
  :alt: Colab


License
-------

``grheat`` is licensed under the terms of the MIT license.
aioflows 0.2.0
Python data flows library to build structured applications
License: MIT
Requires Python: >=3.8

# aioflows
![Github Actions](https://github.com/apatrushev/aioflows/workflows/Spherical%20Python%20CI/badge.svg)
[![PyPI](https://img.shields.io/pypi/v/aioflows?logo=python&logoColor=%23cccccc)](https://pypi.org/project/aioflows)

<p>Asynchronous actors framework</p>

---

**Documentation**: <a href="https://aioflows.github.io" target="_blank">https://aioflows.github.io</a>

**Source**: <a href="https://github.com/apatrushev/aioflows" target="_blank">https://github.com/apatrushev/aioflows</a>

---
This project aims to create a support library for constructing asynchronous applications in Python, using the concept of structured data flows and actors. The current phase is purely a proof-of-concept and serves as a basis for discussion with colleagues and the community. It is not intended for use in any production or personal projects.


## Minimal working example
```python
import asyncio

from aioflows.simple import Printer, Ticker


async def start():
    await (Ticker() >> Printer()).start()


asyncio.run(start())
```

## Udp echo example
```python
import asyncio

from aioflows.network import Udp
from aioflows.simple import Printer, Tee


async def start():
    udp = Udp(local_addr=('127.0.0.1', 5353), reuse_port=True)
    await (udp >> Tee(Printer()) >> udp).start()


asyncio.run(start())
```

You can test it with socat:
```bash
socat - UDP:localhost:5353
```

## Other examples
More examples can be found in [src/examples](https://github.com/apatrushev/aioflows/tree/master/src/examples).

## Installation
 - local
```bash
pip install .
```

 - editable
```bash
pip install -e .
```

 - development
```bash
pip install -e .[dev]
```

 - examples dependencies
```bash
pip install -e .[examples]
```

 - all together
```bash
pip install -e .[dev,examples]
```

 - from github
```bash
pip install git+https://github.com/apatrushev/aioflows.git
```

## Usual development steps
Run checks and tests:
```bash
inv isort flake test
```

Run examples (all ERRORCODE's should be 0/OK or timeout at the moment):
```bash
inv examples | grep ERRORCODE
```

## Similar projects
I found existing solutions that are almost equal to this concept:
 - https://github.com/ReactiveX/RxPY
 - https://github.com/vxgmichel/aiostream
framawarp 0.1.2
Image manipulation on steroids
License: MIT
Requires Python: >=3.8

# framawarp

<div align="center">
  <p>
    <a align="center" href="" target="_blank">
      <img
        width="50%"
        src="resources/logo.png"
      >
    </a>
  </p>
</div>

## Description

`framawarp` is a Python library designed to simplify image manipulation tasks in computer vision projects. It provides a unified interface for wrapping NumPy arrays and PyTorch tensors, making it easy to work with images and perform operations such as color space conversions.

## Installation

To install framawarp, run the following command:

```bash
pip install framawarp
```

## Usage

### Creating a Frame

You can create a `Frame` object by wrapping a NumPy array or a PyTorch tensor:

```python
import numpy as np
from framawarp import Frame

image = np.random.rand(256, 256, 3)  # Example NumPy array
frame = Frame(image)
```

### Manipulating Color Spaces

framawarp makes it easy to convert between different color spaces:

```python
from framawarp import FrameColorSpace

# Convert from RGB to BGR
frame_bgr = frame.cast_color_space(FrameColorSpace.BGR)

# Convert from RGB to HSV with new frame
frame_hsv = frame.cast_color_space(FrameColorSpace.HSV, inplace=False)
```

## Contributing

While we are not actively seeking contributions at the moment, we are always open to suggestions and improvements. Feel free to fork the repository and submit pull requests.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Contact

If you have any questions or suggestions, please feel free to reach out to the maintainer.
set-detect-notify 0.1.0
Detect all the things
License: MIT
Requires Python: >=3.10,<3.12

# Set, Detect, Notify  
Recognize faces/objects in (Wyze Cam) footage and send notifications to your phone (or other devices)

### Features  
- Recognize objects  
- Recognize faces  
- Send notifications to your phone (or other devices) using [ntfy](https://ntfy.sh/)  
- Optionally, run headless with Docker  
- Either use a webcam or an RTSP feed  
    - Use [mrlt8/docker-wyze-bridge](https://github.com/mrlt8/docker-wyze-bridge) to get RTSP feeds from Wyze Cams  


## Prerequisites  
### Poetry/Python  
- Camera, either a webcam or a Wyze Cam  
    - All RTSP feeds _should_ work, however.
- Python
- Poetry
### Docker
- A Wyze Cam  
    - Any other RTSP feed _should_ work, as mentioned above
- Python
- Poetry

## What's not required  
- A Wyze subscription  

## Usage    
### Installation  
1. Clone this repo with `git clone https://github.com/slashtechno/wyze-face-recognition.git`  
2. `cd` into the cloned repository  
3. Then, either install with [Poetry](https://python-poetry.org/) or run with Docker  

#### Docker  
1. Modify to `docker-compose.yml` to achieve desired configuration
2. Run in the background with `docker compose up -d

#### Poetry  
1. `poetry install`  
2. `poetry run -- set-detect-notify`  
### Configuration  
The following are some basic CLI options. Most flags have environment variable equivalents which can be helpful when using Docker. 

- For face recognition, put images of faces in subdirectories `./faces` (this can be changed with `--faces-directory`) 
    - Keep in mind, on the first run, face rec
- By default, notifications are sent for all objects. This can be changed with one or more occurrences of `--detect-object` to specify which objects to detect
    - Currently, all classes in the [COCO](https://cocodataset.org/) dataset can be detected
- To specify where notifications are sent, specify a [ntfy](https://ntfy.sh/) URL with `--ntfy-url`
- To configure the program when using Docker, edit `docker-compose.yml` and/or set environment variables.
- **For further information, use `--help`**

### How to uninstall  
- If you used Docker, run `docker-compose down --rmi all` in the cloned repository
- If you used Poetry, just delete the virtual environment and then the cloned repository
xiezhi-ai 0.0.0
Anomaly detection for one-dimensional data
License: MIT
Keywords: python,anomaly detection,one-dimentional data

### xiezhi: The First One-dimensional Anomaly Detection Tool

### Install

pip install xiezhi-ai

### Usage
The inputs include data, beta, and alpha.

data: The current version only supports the detection of one-dimensional data, so the data should be a list. 

beta and alpha are set between 0 and 1 and beta is smaller than alpha, if there are few anomalies, beta and alpha can be set close to 1; 
otherwize, it should be set close to 0.5. If the number of anomalies are unknown, then both of beta and alpha should be close to 0.5. 

Below is the example:

```python
import xiezhi as xz

data=[1,2,3,4,5,6,7,9,10,20] # here 20 is the anomaly
benign_data=xz(data,0.7,0.9) # xiezhi will return the benign data
```
pciw.py 0.10.0.dev1
Module for obtaining system information.
License: MIT
Requires Python: >=3.9,<4.0
Keywords: pciw,pciw.py,info,system,os,bios,videocard,motherboard,ram

# pciw.py
This module can obtain __full information__ about the `CPU`, `RAM`, `GPU`, `Monitors`, `Motherboard`, `Videocards` and `BIOS`.

So far, it __only works fully__ on a `Windows` system.
## Install
```
pip install -U pciw.py
```
## Example
For the example made by `__main__.py`:
```
python -m pciw
```
## Author
- Roman Slabicky
    - [Vkontakte](https://vk.com/romanin2)
    - [GitHub](https://github.com/romanin-rf)