semvec/pypi-packages huggingface dataset:
notebookquery 0.1.1
SQL integration and table display for ipython notebooks
Requires Python: >=3.8

# `notebookquery`: SQL integration and table display for IPython notebooks

Install with `pip`:

```bash
pip install notebookquery
```

Then just import into a notebook:

```python
import notebookquery
```

From there you can choose a database with `%db` at the start of a cell, for instance:

```python
%db postgresql:///example
```

Then write a query with `%%sql`:

```python
%%sql

select * from example_table;
```
ialab-core 0.2.5
A utility to help you in your IA projects

# Introduction

I find myself writting the same code over again every time I want to run some experiment or try
some new IA stuff most of the time loosing focus on the important thing I'm trying to learn
or understand. In order to avoid this pattern I tried to write a small framework that help me
have those standard task already solved and at the same time helps me structure the code
in a readable and maintainable way.

# Installation

This project has been developed with python 3.6. 

```bash
pip3 install ialab-core
```

# Architectural considerations

I will try to explain they why by means of an example in computer vision. 
Most of the time I try some experiment it happens to be as follows:

* I need to read video either from disk or from my notebook camera.
* The image needs to be scaled for performance reasons
* I need to run some sort of algorithm on the image (this may imply one or a secuence of algorithms)
* I want to display the result or optionally display it and send the result to an image or video file

Let's take those steps into a more abstract representation


Read Image -> Scale Image -> Face Detection (to say something specific) -> Display Result
-> Send to disk

This looks very similar to a pipes and filters architecture where I can send the output 
for some step to one or more processors. Nothing new here this is just a graph structure
as it is happening on most new technologies stacks that try to help us building
better and more maintainable software.

Each processing node in this architecture will be called a Processor. 
There are special types of Processors which are the input and output ones. The main
difference between them is that input processors can run and control the execution (this will
change in future versions where a separate executor will appear) and output processor don't try
to offer their output for further processing. On the other hand a regular processor will do
something with the input data and will offer this data for any other processor that
is interested in doing so.

## Example

As an example let's thing you have a folder with images where each image contain somewhere
in it the face of a person and the file is named as the person. You want to do face detection
using a siamesse network but first you want to extract the faces from the images in order to
reduce the memory footprint, loading time and the size of the application you deliver
to your customer.

To do this you can write down the followin short application using our library.

```python
graph = FaceRecognition(original_pictures_path, [
        FaceExtractor([
            ImageWriter(face_picture_path)]
        )
    ])

video = ImageInput(original_pictures_path, (320, 240), [graph])
video.run()
```

## Running the examples

### YoloV3

To run YoloV3 you need to download the configuration files and place them into 
./modes/yolov3. There are 3 files that need to be downloaded yolov3.cfg, yolov3.weights
and coco.names. These files can be downloaded from https://pjreddie.com/darknet/yolo/.

After downloading just execute python3 obj_recog.py
jblibpandas 1.1.1
JustBard's Python Pandas Utilities

# jblib-pandas
## Author: Justin Bard

This module was written to minimize the need to write the pandas related functions I use often. These modules were stripped out of jblib to minimize the dependencies required to import jblib. I.E. Pandas

---
The source code can be viewed here: [https://github.com/ANamelessDrake/jblib-pandas](https://github.com/ANamelessDrake/jblib-pandas)

More of my projects can be found here: [http://justbard.com](http://justbard.com)

---

INSTALL:  ` python3 -m pip install jblibpandas `

---
` from jblibpandas import mean_deviation `

```
    DESCRIPTION:
        This function takes a Pandas DataFrame column in and then returns a series of calculated mean deviations

    FUNCTION:
        mean_deviation(data, mean=None)

    EXAMPLE:
        data["MeanDeviation"] = pd.Series(mean_deviation(data['column']), index=data.index)
```

---
` from jblibpandas import standard_deviation `

```
    DESCRIPTION:
        This function takes a Pandas DataFrame column in and then returns the calculated standard deviation

    FUNCTION:
        standard_deviation(data, mean=None)

    EXAMPLE:
        standard_dev = standard_deviation(data['column'])
```
pyloopkit-test 0.0.15
Python implementation of the Loop algorithm
Requires Python: >=3.6

# PyLoopKit
A set of Python tools for building closed-loop insulin delivery apps (Python port of LoopKit)

<a href="/example_files/example_prediction_figure.png"><img src="/example_files/example_prediction_figure.png?raw=true" alt="Sample Prediction Figure from PyLoopKit"></a>

[Link to Tidepool Loop repository version used for algorithm](https://github.com/tidepool-org/Loop/tree/8c1dfdba38fbf6588b07cee995a8b28fcf80ef69)

[Link of Tidepool LoopKit repository version used for algorithm](https://github.com/tidepool-org/LoopKit/tree/57a9f2ba65ae3765ef7baafe66b883e654e08391)

# To use this project
## Please review [the documentation](docs/pyloopkit_documentation.md) for usage instructions, input data requirements, and other important details.

### To recreate the Virtual Environment
1. This environment was developed with Anaconda. You'll need to install [Miniconda](https://conda.io/miniconda.html) or [Anaconda](https://anaconda-installer.readthedocs.io/en/latest/) for your platform.
2. In a terminal, navigate to the directory where the environment.yml 
is located (likely the PyLoopKit folder).
3. Run `conda env create`; this will download all of the package dependencies
and install them in a virtual environment named py-loop. PLEASE NOTE: this
may take up to 30 minutes to complete.

### To use the Virtual Environment
In Bash run `source activate py-loop`, or in the Anaconda Prompt
run `conda activate py-loop` to start the environment.

Run `deactivate` to stop the environment.