semvec/pypi-packages huggingface dataset:
pypygifmaker 0.0.1.2
You can make a simple gif easily with this GIFMAKER
License: MIT
Requires Python: >=3.6

## Project Description

The simple way of making GIF.

You can make gif with image urls or PIL image list.

## Installation

The recommended way to install is via [pip](https://pypi.org/project/pip/)

```bash
$ pip install pypygifmaker
```

## Getting Started

```python
from pygifmaker.pygifmaker import GifMaker
gifmaker = GifMaker()
```

-   output_filename: ex) "output.gif"
-   images: List of image src
-   fps: 1 frame per second
-   loop: 0 for infinite 1 for once

<strong>If you want to make GIF with image urls</strong>

```python
images = [## Image src]

GifMaker.Make(output_filename, images, fps, loop)
```

<strong>If you want to make GIF with PIL images</strong>

```python
pil_images = [## PIL Image]

GifMaker.PIL(output_filename, pil_images, fps, loop)
```

## Support

If you find an bug, have any questions about how to use py-gifmaker or have suggestions for improvements then feel free to file an issue on the [Github project page](https://github.com/yoonhero/gifmaker/issues).

## License

All of the code contained here is licensed by the MIT.
unicell 0.0.1.post0
Universal cell segmentation
License: MIT

# UniCell
UniCell is a universal cellular segmentation tool for multi-modality microscopy images. It has three main features

- It works for various microscopy images, especially for the RGB images, e.g., bone marrow slides.
- It works for various image format (e.g., png, bmp, jpg, tif, tiff) without format converting and does not require users to manually select segmentation models and image channels.
- The inference speed is fast (~0.07s for 256x256 image and ~0.33s for 512x512 image on NVIDAI 2080Ti). 



## Installation

```bash
pip install git+https://github.com/bowang-lab/unicell.git
```



## Train UniCell

```bash
unicell_train -dir <path to training set> --model_folder <unicell> --batch_size 32
```

Training set folder structure

```bash
training_set/
|----images
|--------img1.png
|--------img2.jpg
|--------img3.bmp
|--------img4.tif
|--------img5.tiff
|----labels
|--------img1_label.tiff
|--------img2_label.tiff
|--------img3_label.tiff
|--------img4_label.tiff
|--------img5_label.tiff
```

UniCell does not have limitation on the image format. The corresponding labels should have a suffix `_label.tiff`. 



## Inference

```bash
unicell_predict -i <input path> -o <output path> --pretrain_model unicell --contour_overlay
```



## Compute metrics

We provide a interface to compute various metrics for cell segmentation results, including F1 score, precision, recall, the number of missing cells, the number of false-positive cells, and dice

```bash
com_metric -g <path to ground truth folder> -s <path to segmentation folder> -thre 0.5 0.7 0.9 -o <path to save folder> -n <csv name>
```



## Graphical User Interface (GUI)

We develop a GUI plugin based on [napari](https://napari.org/stable/), which enables users who may not have coding experience to analyze their microscopy images visually in real time.

Install GUI: pip install napari-unicell

![napari-gui](./example/unicell-napari.png)





## [Online demo](https://huggingface.co/spaces/junma/UniCell)

We deploy an online demo on huggingface, which enables users to directly upload the cell images to get the segmentation results. 

> Remark: huggingface provides 2 free CPU for the deployment. So the inference can only use CPU, which is a little bit slow for large images (e.g., 1000x1000). We recommend using the command line interface or GUI  to analyze large images if GPU is available on your local desktop. 

![huggingface](./example/huggingface_demo.png)
UniCell 0.0.1
Universal cell segmentation
License: MIT

# UniCell
UniCell is a universal cellular segmentation tool for multi-modality microscopy images. It has three main features

- It works for various microscopy images, especially for the RGB images, e.g., bone marrow slides.
- It works for various image format (e.g., png, bmp, jpg, tif, tiff) without format converting and does not require users to manually select segmentation models and image channels.
- The inference speed is fast (~0.07s for 256x256 image and ~0.33s for 512x512 image on NVIDAI 2080Ti). 



## Installation

```bash
pip install git+https://github.com/bowang-lab/unicell.git
```



## Train UniCell

```bash
unicell_train -dir <path to training set> --model_folder <unicell> --batch_size 32
```

Training set folder structure

```bash
training_set/
|----images
|--------img1.png
|--------img2.jpg
|--------img3.bmp
|--------img4.tif
|--------img5.tiff
|----labels
|--------img1_label.tiff
|--------img2_label.tiff
|--------img3_label.tiff
|--------img4_label.tiff
|--------img5_label.tiff
```

UniCell does not have limitation on the image format. The corresponding labels should have a suffix `_label.tiff`. 



## Inference

```bash
unicell_predict -i <input path> -o <output path> --pretrain_model unicell --contour_overlay
```



## Compute metrics

We provide a interface to compute various metrics for cell segmentation results, including F1 score, precision, recall, the number of missing cells, the number of false-positive cells, and dice

```bash
com_metric -g <path to ground truth folder> -s <path to segmentation folder> -thre 0.5 0.7 0.9 -o <path to save folder> -n <csv name>
```



## Graphical User Interface (GUI)

We develop a GUI plugin based on [napari](https://napari.org/stable/), which enables users who may not have coding experience to analyze their microscopy images visually in real time.

Install GUI: pip install napari-unicell

![napari-gui](./example/unicell-napari.png)





## [Online demo](https://huggingface.co/spaces/junma/UniCell)

We deploy an online demo on huggingface, which enables users to directly upload the cell images to get the segmentation results. 

> Remark: huggingface provides 2 free CPU for the deployment. So the inference can only use CPU, which is a little bit slow for large images (e.g., 1000x1000). We recommend using the command line interface or GUI  to analyze large images if GPU is available on your local desktop. 

![huggingface](./example/huggingface_demo.png)
ast-names 0.1.0
Collect top level variable names using the ast.
License: MIT
Requires Python: >=3.8

# ast_names

Collect top level variable names using the ast.


## Installation

```
pip install ast_names
```

## Usage

```pycon
>>> from ast_names import ast_names
>>> ast_names("""
... import sys, os
... import sys as foo
...
... from foo import (
...     bar as baz,
...     alpha
... )
...
... MYCONSTANT = 1
...
... def my_func():
...     ...
...
... class MyClass:
...     ...
... """)
{'os', 'MYCONSTANT', 'alpha', 'baz', 'foo', 'sys', 'MyClass', 'my_func'}
```
XPlaneApi 0.0.6
API Python Client for C++ Xplane Server
License: MIT
Requires Python: >=3.7
Keywords: XPlane API

# XPlane Python Client

This repository contains a Python client to send commands directly to XPlane through the C++ server.

## Setup
All that is required is to pip install the package.

```
pip install XPlaneApi
```

Then we can import it into a project as follows:

```
from XPlaneApi import XPlaneClient
```

## Running the Setup

* Start XPlane and wait until a flight has been resumed and you are in the aircraft
* Navigate to the folder containing the C++ Server for Xplane
	* Modify the subscriptions.txt to add or remove datarefs that you wish to subscribe to.
	* Execute the libXplane-udp-client.exe when ready
* Begin the Python Client as required

## Python API Documentation

The Python API currently has 3 functions available to use as follows:

Connect to the C++ Server by using the connect function seen below.

```
connect(self):
```

Disconnect cleanly from the C++ Server by using the connect function seen below.

```
disconnect(self):
```

To receive the value of a dataref, use the getDataRef function to receive the value as a string.

```
getDataRef(self, dref):
```

To modify the value of a dataref, use the setDataRef function to alter the value. Note, value must be in string format.

```
setDataRef(self, dref, value):
```

To send a command to the cockpit, use the sendCommand, input must be in the string format.

```
sendCommand(self, dref):
```

## Example Program

This example program comes bundled in the package under examples.

```
from XPlaneApi import XPlaneClient
import time

# Specify a topic for your program to communicate through
# Specify also as input IP address of pc containing xplane if not local
client = XPlaneClient("Python1")

# Call the connect command
client.connect()

# Modify and read value at same time
for i in range(0, 100, 1):
    if client.setDataRef("sim/cockpit2/engine/actuators/throttle_ratio[0]", str(i/100)) == False:
        print("command did not execute correctly!")

    dataRefVal = client.getDataRef("sim/cockpit2/engine/actuators/throttle_ratio[0]")
    print(f"Value received for dref = {dataRefVal}")
    time.sleep(0.005)

# Disconnect the client cleanly
client.disconnect()
```
cinet 0.0.16
Scikit-Learn interface for CINET PyTorch siamese neural network
License: MIT
Requires Python: >=3.9,<4.0

# cinet

Scikit-Learn interface for CINET PyTorch siamese neural network. 

DeepCINET is a deep "siamese" neural network architecture, where a contrastive loss function is used to learn feature weights that maximally discriminate relative response/target between valid pairs of training data. A hyper-parameter, delta, is used to define what a valid pair is by setting a minimum difference in response/target value for pairs to be included in model training, with the intuition that useful weights cannot be learned from samples that are too close together in response-space. 

Concordance index is then used to assess rank accuracy. Concordance index was chosen because it is a non-parametric statistic that does not make 
assumptions on data distributon or homoscedasticity. It can detect non-linear, monotonic associations.

ECINET is a one-dimensional neural network, which makes it essentially a linear regression model with regularization. It is comparable to model architectures like ElasticNet. It can be used
to assess if improved performance is delivered by the added complexity of DeepCINET.

Note, however, that siamese networks go hand-in-hand with few shot learning approaches. The idea is that features learned from large data in CINET can then be applied to learning done 
on smaller real-world data in a transfer learning approach. 

An initial implementation, trained on gene set expression data from cancer cell lines and meant to predict drug sensitivity rank, is available on the BHKLab's public GitHub at https://github.com/bhklab/cinet. 

## Installation

```bash
$ pip3 install cinet
```

## Usage

CINET can be used like any other Scikit-Learn model. 

```python
# Import CINET
from cinet import *

# Create a DeepCINET model
model = deepCINET()
# Or, create an ECINET model
model = ECINET()

# Standard Scikit-Learn syntax
model.fit(X,y)
model.predict(X)
model.score(X,y)

# You can use it with things like GridSearchCV easily
GridSearchCV(deepCINET(device='cpu', batch_size=2**12), param_grid, refit = True, verbose = 3,n_jobs=3)
```

## Contributing

Interested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.

## License

`cinet` was created by Kevin Tabatabaei and Christopher Eeles. It is licensed under the terms of the MIT license.

## Credits

`cinet` was created with [`cookiecutter`](https://cookiecutter.readthedocs.io/en/latest/) and the `py-pkgs-cookiecutter` [template](https://github.com/py-pkgs/py-pkgs-cookiecutter).
pyAuthManager 0.1.4.2
Authentication Manager with support of AWS, GCP and Azure.
License: MIT

Authentication Manager with support of AWS, GCP and Azure

Have you ever felt sucked reading too much documentation before creating a simple authentication service ?
Well, pyAuthManager project aims to remove this headache and let you focus on your service.
Cloud native authentication service that supports the following features:
- AWS, GCP & Azure support
- MFA
- Identity Pool (somehow)
- More to come

0.1.4.2
Upgrade dependencies

0.1.4.1
Upgrade dependencies

v0.1.4
Cleanup dependencies

v0.1.3.1
Update version requirements

v0.1.3
Upgrade dependencies

v0.1.2
Set correctly provider

v0.1.1
GCP Support fixes

v0.1.0
AWS & GCP Support:

* provider: email + password

* Signup & confirmation

* Signin

* Password reset

* Token validation & refresh