semvec/pypi-packages huggingface dataset:
bloby 1.2.1
Package that performs blob detection on 3D TIF Stacks
Keywords: sample setuptools development

# _bloby_
Package that performs blob detection on 3D TIF Stacks <br/>

## Sytem Requirements

The recommended way to use this package is to install [Docker](https://store.docker.com/search?offering=community&type=edition).
Docker is currently available on OS X El Capitan 10.11 and newer macOS releases, the following Ubuntu versions: Zesty 17.04
(LTS), Yakkety 16.10, Xenial 16.04 (LTS), Trusty 14.04 (LTS), and Windows 10.

### Software Dependencies (with version numbers)

The only software dependency needed if using the recommended method is Docker. The following dependencies are included in the Docker Image.

Python depedencies:

colorama --- 0.3.9<br/>
scikit_image --- 0.13.1<br/>
scipy --- 1.0.0<br/>
numpy --- 1.13.1<br/>
requests --- 2.18.4<br/>
intern --- 0.9.4<br/>
tifffile --- 0.12.1<br/>
tqdm --- 4.19.5<br/>
matplotlib --- 2.1.0<br/>
progressbar2 --- 3.34.3<br/>
scikit_learn --- 0.19.1<br/>
pyfiglet --- 0.7.5<br/>

### Versions tested on
We have tested the Docker image and build on macOS High Sierra (on MacBook Pro with 2.9 GHz Intel Core i7 and 16 GB RAM) and Ubuntu Xenial 16.04.3 LTS.

## Installation Guide

Once Docker is installed on your machine, pull the `srivathsapv/bloby` image from Docker Hub [here](https://hub.docker.com/r/srivathsapv/bloby) as follows: <br/>

```
docker pull srivathsapv/bloby
```

It will typically take around 3 minutes to pull the entire Docker image.

## Demo

### Instructions to run on data

Create a `.docker-env` file and add your `BOSS_TOKEN` value as follows. This is needed to upload the detected centroids to BOSS
for visualization

```
BOSS_TOKEN=<your_boss_token>
```

In order to use the functionality built into this Docker image, you need to run the Docker image:

```
docker run -p 3000:3000 --env-file .docker-env srivathsapv/bloby
```

This should print a link to the terminal console that looks like this: <br/>

```
http://0.0.0.0:3000/?token=SOME_TOKEN
```

Go to this link in your browser by copying and pasting it. <br/>

Next, click on `Package Usage.ipynb`. Once the notebook opens, you can run all cells by clicking on 'Cell' and then 'Run All'.

The expected run time for this demo is < 10 seconds.

### Expected Output

You should see a message showing the successful upload to BOSS with a URL!

## Congrats, you've succesfully run _bloby_!

## Other resources:

* [Blob detection algorithm pseudocode](https://github.com/NeuroDataDesign/bloby/wiki/Detection-Algorithm-Pseudocode)
* [Dev docs](https://neurodatadesign.github.io/bloby/)
keras-pickle-wrapper 1.0.5
A small library that wraps Keras models to pickle them.
Keywords: keras

# `keras_pickle_wrapper`

This small library exposes a KerasPickleWrapper class that allows keras models to be pickled, and even used across multiprocessing (or with a library like [job\_stream](https://github.com/wwoods/job_stream)).

It won't be necessary if https://github.com/fchollet/keras/issues/789 is ever properly resolved.

## Installation

`pip install keras-pickle-wrapper`

## Usage

```python

import keras
import pickle
import numpy as np

from keras_pickle_wrapper import KerasPickleWrapper

ins = keras.layers.Input((2,))
x = ins
x = keras.layers.Dense(3)(x)
x = keras.layers.Dense(1)(x)
m = keras.models.Model(inputs=ins, outputs=x)
m.compile(loss='mse', optimizer='sgd')

# Wrap a compiled model
mw = KerasPickleWrapper(m)

# Calling the object returns the wrapped Keras model
mw().fit([[0,0], [0,1], [1,0], [1,1]], [[0], [1], [1], [0]])

# Pickle / unpickle the wrapper
data = pickle.dumps(mw)
mw2 = pickle.loads(data)
output_1 = mw().predict(np.asarray([[0, 0]]))
output_2 = mw2().predict(np.asarray([[0, 0]]))

# You can unload the object from memory as well
mw.unload()

# The object will remain unloaded until requested again
output_3 = mw().predict(np.asarray([[0, 0]]))

print("All outputs:")
print(output_1)
print(output_2)
print(output_3)

# If using tensorflow and pickling / unpickling a lot, be sure to clear the 
# session:
keras.backend.clear_session()

# When using a custom layer class, be sure to register it so the pickler works
class MyLayer(keras.layers.Layer):
    pass  # ...
KerasPickleWrapper.register(MyLayer)
```

If your model takes 1GB of RAM, the default approach should require 2GB additional RAM to encode, as it dumps to shared memory by default.  To disable this, set `KerasPickleWrapper.NO_SHM = True`.  Temporary files will then be written to the standard temporary directory.  Using `KerasPickleWrapper.unload(clear_session=True)` prior to pickling combined with `NO_SHM` should eliminate excess memory consumption, but clears the session (session clearing only applies to Tensorflow at the moment).


## Changelog

* 2018-7-17 - Fix for Python 2 in setup.py (FileNotFoundError not existing in Python 2.7), up to V1.0.5.
* 2017-9-19 - Fix for Python 2, up to V1.0.3.
* 2017-8-17 - Renamed to keras-pickle-wrapper because PyPI.  V1.0.2.
* 2017-8-17 - Packaged up KerasWrapper for PyPI distribution.
ysa 0.1.4
python client for the YSA api

# YSA - You shall ask -- API PYTHON CLIENT

## What is YSA?

A Restful API that runs a feature flagging status storage as a service.
[YSA-REPO](https://github.com/sjortiz/YSA)

## What is this client for?

It makes automatic all the interaction between your code and the api on execution time,
allowing you to relax yourself knowing that you don't need to code such interaction.
[YSA-PYTHON-CLIENT-REPO](https://github.com/sjortiz/YSA-PY)
vehicular 0.1.0
a craigslist vehicle search cli app

# Vehicular

I like to ride motorcycles (Dualsports, to be specific) and it's well known that the 
best place to look for a good deal on used bikes is craigslist.  In order to jump on
a deal, you've got to constantly troll craigslist for new posts.  

However, I like to automate things when I can, so I wrote this little CLI app to 
search for me.  It uses [feedparser](https://github.com/kurtmckee/feedparser) to 
sort through craigslist rss feeds and sends you an email notification when it finds
new matches.

# Usage

Vehicular runs in a custom shell that manages all the various search parameters.
There are a lot of possible search parameters, inside the shell run `help` to view 
all the commands. and `help <command>` to view help info for `<command>`.  Tab
autocomplete works for commands that have specific options.  Using it is encouraged as
incorrectly typed parameters will fail as invalid.

 Of all the parameters, only a few are required: `city`, `seller_type`,
`vehicle_type` and `make_model`.

* `city`
    * Run `city help` to view all available cities in which to search.  
    Tab autocomplete is your friend with this one.

* `seller_type`
    * Defaults to search for results from both dealers and owners
    * Run `seller_type dealer` or `seller_type owner` to change it to your desired 
    option

* `vehicle_type`
    * Craigslist splits vehicle listings up into motorcycles and cars/trucks
    * run `vehicle_type motorcyle` or `vehicle_type cars/trucks` to select 
    which search you want to run.

* `make_model`
    * Selects the make / model you're looking for.  Pretty obvious once you think
    about it.

All the other parameters are optional.

After having selected the parameters, run `add_search`, which compiles the selected options into
an RSS URL, which is stored in the database.  After having added the search, running 
`run_search` will parse the searches and send an email notification if matches are found.

# Installation

Install via `pip install vehicular`

# License

GPLv3, see LICENSE.txt
octant 0.0.13
Objective Cyclone Tracking ANalysis Tools

[![LICENSE](https://anaconda.org/dennissergeev/octant/badges/license.svg)](LICENSE)
[![Python 3.6](https://img.shields.io/badge/python-3.6-blue.svg)](https://www.python.org/downloads/release/python-360/)
[![Conda](https://anaconda.org/dennissergeev/octant/badges/version.svg)](https://anaconda.org/dennissergeev/octant)
[![Build Status](https://travis-ci.com/dennissergeev/octant.svg?branch=master)](https://travis-ci.com/dennissergeev/octant)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.1313078.svg)](https://doi.org/10.5281/zenodo.1313078)


# octant
Objective Cyclone Tracking ANalysis Tools

## Installation
`octant` depends on the following packages:
  - cython
  - matplotlib
  - numpy
  - pandas
  - xarray

### With conda
```bash
conda install -c dennissergeev octant
```

### From source
```bash
git clone https://github.com/dennissergeev/octant.git

cd octant

python setup.py install
```
gitchecker 2.0.0
Python GIT tool to check pending changes and get last commit info

[![Travis build](https://travis-ci.org/Crul/gitchecker.svg?branch=master)](https://travis-ci.org/Crul/gitchecker) 
[![Coverage Status](https://coveralls.io/repos/github/Crul/gitchecker/badge.svg?branch=master)](https://coveralls.io/github/Crul/gitchecker?branch=master)
[![pypi-version](https://img.shields.io/pypi/v/gitchecker.svg)](https://pypi.org/project/gitchecker/)
[![pypi-wheel](https://img.shields.io/pypi/wheel/gitchecker.svg)](https://pypi.org/project/gitchecker/)
[![pypi-format](https://img.shields.io/pypi/format/gitchecker.svg)](https://pypi.org/project/gitchecker/)
[![pypi-pyversions](https://img.shields.io/pypi/pyversions/gitchecker.svg)](https://pypi.org/project/gitchecker/)
[![pypi-implementation](https://img.shields.io/pypi/implementation/gitchecker.svg)](https://pypi.org/project/gitchecker/)
[![pypi-status](https://img.shields.io/pypi/status/gitchecker.svg)](https://pypi.org/project/gitchecker/)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/db52183d1abe4ae389fddbf9911c83b2)](https://www.codacy.com/app/Crul/gitchecker)
# Python GIT tool to check pending changes and get last commit info 

``gitchecker.check_status_and_get_commit_info()`` checks if there is
any pending changes in GIT repository status and returns the last commit info:

- sha (string): commit SHA (7 digits length)
- author (string): author name
- authored_datetime (datetime): author datetime
- committer (string): committer name
- committed_datetime (datetime): committer datetime

By default it raises an ``Exception`` if there are any pending changes but
it can be configured to only show a warning instead.

## Requirements

- Python 3.5 or newer
- Git 1.7.0 or newer, because [gitpython dependency](https://gitpython.readthedocs.io/en/stable/intro.html#requirements)

## Install

```
pip install gitchecker
```

## Demo Usage
```python
import gitchecker
commit_info = \
    gitchecker.check_status_and_get_commit_info(repo_path="",
                                                warning_instead_of_error=False,
                                                ignore_untracked_files=False,
                                                ignore_files_regex=None,
                                                logger=None)

print("commit", commit_info)
```
The displayed values of the parameters are the default ones.

If a ```logger``` is provided, it will be used only if it has an ```error()``` 
or ```warning()``` method. The required method depends on the value of 
```warning_instead_of_error```. If no ```logger``` provided or no proper 
log function exists in ```logger``` , ```print()``` will be used instead.

Ignoring untracked files (```ignore_untracked_files=True```) or 
Ignoring by regex (```ignore_files_regex="regex"```) will ignore them completely,
not raising errors and not showing warnings.

## Testing
The GIT status must be clean to run functional test.

    python setup.py test

To run only unit tests, use:

    python -m pytest --pep8 --cov=gitchecker --cov-report=term-missing --cov-report=html -vv -x -k unit