semvec/pypi-packages huggingface dataset:
pygouv 0.1.0
API wrapper for data.gouv.fr


# pygouv

`pygouv` is a __non official__ Python API wrapper for [data.gouv.fr](https://www.data.gouv.fr/fr/), the French Official Open Data Portal.

## Installation

You can install `pygouv` with:

`pip install pygouv`

## Usage

```python

import pygouv as gv

```

### gv.home( ) and gv.home_compact()

Displays the datasets that are currently exhibited within the home page of the data.gouv.fr portal.

`gv.home()` returns all the columns that are provided by the data.gouv API and can be overwhelming. In this context, there is the `gv.home_compact()` that as its name implies much more compact and contains only the most important columns: `id, title, last_update`

### gv.site_metrics( )

Provides global metrics related to the data.gouv.fr portal:

### gv.search( ) and gv.search_compact()

Searches for specific data sets through the data.gouv API according to the pattern provided into the `query` parameter. It takes three arguments `query`, `page` and `page_size`:

```python
gv.search(query='cafÃ©s Ã  paris',
          page = 0, # look at page 0 (the default)
          page_size = 20) # pull 20 results
```

`gv.search()` returns all the columns provided by the API. `gv.search_compact()` returns only three columns: `id, description, last_update`

## gv.explain( )

Provides in **French** a detailed description of a data set. It takes one mandatory argument which is the `dataset_id` that you can get from output of the `search()` function.

```python
print(gv.explain('5f9b902d3784843c84d5f959'))
```

    **Ce jeu de donnÃ©es recense les dÃ©clarations de terrasse Ã©phÃ©mÃ¨re.**

    La Ville de Paris a pris la dÃ©cision d'autoriser l'extension gratuite des terrasses pour les cafÃ©s, bars et restaurants.

    Habituellement soumises Ã  une autorisation, les extensions provisoires sont exceptionnellement enregistrÃ©es Ã  titre gratuit, et sont valables jusqu'en juin 2021.

    La dÃ©claration est effectuÃ©e via un tÃ©lÃ©service sur Paris.fr. Chaque commerÃ§ant doit signer et afficher une charte d'engagement.

    [Plus d'informations: sur Paris.fr](https://www.paris.fr/pages/reouverture-des-bars-et-restaurants-agrandir-ou-creer-sa-terrasse-7847)

    Description des donnÃ©es :

    Â· \- Reference DÃ©claration (NumÃ©ro de la dÃ©claration)

    Â· \- Nom Commerce

    Â· \- Adresse Commerce et coordonnÃ©es gÃ©ographiques (X ; Y)

### gv.resources( ) and gv.resources_compact():

`gv.resources()` lists all the available resources within a specific data set. `gv.resources_compact()` is its equivalent except that it returns only two columns: `format, url` 

```python
gv.resources('5f9b902d3784843c84d5f959')
```

### suggest_territory( )

Returns suggested territory pages according to the query provided by the user:

```python
gv.suggest_territory(query = 'paris', result_size=10)

```

## Code of Conduct

Please note that the `pygouv` project is released with a [Contributor Code of Conduct](https://contributor-covenant.org/version/2/0/CODE_OF_CONDUCT.html). By contributing to this project, you agree to abide by its terms.
gl-coarsener 2.0.0
GL-Coarsener, a graph learning based coarsening method
Requires Python: >=3.6
Keywords: multigrid,gl-coarsener,graph,machine learning, graph embedding,representation learning

# GL-Coarsener
A python implementation of GL-Coarsener method, as proposed in [GL-Coarsener: A Graph representation learning framework to construct coarse grid hierarchy for AMG solvers, arXiv:2011.09994](https://arxiv.org/abs/2011.09994).

If you find our code or paper useful in your research, please consider citing:
```
@misc{namazi2020glcoarsener,
      title={GL-Coarsener: A Graph representation learning framework to construct coarse grid hierarchy for AMG solvers}, 
      author={Reza Namazi and Arsham Zolanvari and Mahdi Sani and Seyed Amir Ali Ghafourian Ghahramani},
      year={2020},
      eprint={2011.09994},
      archivePrefix={arXiv},
      primaryClass={math.NA}
}
```

# Installation
```bash
pip install gl-coarsener
```

# Usage
### Import the package
```python
from glcoarsener import Coarsener
```
### Input
You should construct a _Coarsener_ object with the adjacency matrix that you want to coarsen. The input must be of type _scipy sparse CSR matrix_.
```python
from scipy import sparse
adjacency_matrix = sparse.random(1000, 1000, format='csr')
coarsener = Coarsener(adjacency_matrix)
```
### Applying the method
```python
prolongation_operator = coarsener.apply(
    dimensions=100,
    walk_length=20,
    num_walks=10,
    p=0.1,
    q=1,
    number_of_clusters=adjacency_matrix.shape[0] // 5,
    clustering_method='kmeans',
    workers=1
)
```
### Getting the coarse (smaller) adjacency matrix
```python
restriction_operator = prolongation_operator.transpose()
coarse_matrix = restriction_operator.dot(adjacency_matrix).dot(prolongation_operator)
print(coarse_matrix)
```
# Contributing
Any contribution is **greatly appreciated**. If you think you can improve this work, please open a pull request.

1. Fork the Project
2. Create your Feature Branch (`git checkout -b feature/Improvement`)
3. Commit your Changes (`git commit -m 'Add some Improvement'`)
4. Push to the Branch (`git push origin feature/Improvement`)
5. Open a Pull Request

# Contact
If you have any questions, please do not hesitate to contact me:
- Personal Webpage: https://rezanmz.com/
- Email: rezanmz@ymail.com
shapeandshare-dicebox-core 3.5.0
Dicebox Core
Requires Python: >=3.7

# Dicebox Core Libraries

Core libraries for the Dicebox API platform.

Notes
-----
* run_unit_tests.sh created to wrap python unit test runner.

Requirements
------------

**Python Module Requirements**

The requirements can be automatically installed using the below command:
```
    pip install -r requirements.txt
```

References
----------

[Matt Harvey](https://github.com/harvitronix) thank you, for without you Dicebox would not be.  Much of the current implementation of dicebox comes from Matt's project below.  I originally forked Matt's work and used it until it outgrew what it was.

* [Blog Post](https://blog.coast.ai/lets-evolve-a-neural-network-with-a-genetic-algorithm-code-included-8809bece164) & [Code](https://github.com/harvitronix/neural-network-genetic-algorithm)

**Projects that I worked with heavily during prior implementations of dicebox**

* [Tensorflow & the 'slim' samples](https://github.com/tensorflow/tensorflow)
* [Tensorflow models](https://github.com/tensorflow/models)
* [EasyTensorflow](https://github.com/calvinschmdt/EasyTensorflow)

**Additional projects used here, or where reference material for Dicebox**

* D20 Roll Fairness Evaluation | [Blog Post](http://www.markfickett.com/stuff/artPage.php?id=389) & [Code](https://github.com/markfickett/dicehistogram)
* Keras | [Site](https://keras.io/) & [Code](https://github.com/fchollet/keras)
* [JPG-and-PNG-to-MNIST](https://github.com/gskielian/JPG-PNG-to-MNIST-NN-Format)


Contributing
------------
1. Fork the repository on Github
2. Create a named feature branch (like `add_component_x`)
3. Write your change
4. Write tests for your change (if applicable)
5. Run the tests, ensuring they all pass
6. Submit a Pull Request using Github

License and Authors
-------------------
MIT License

Copyright (c) 2017-2021 Joshua C. Burt

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
vl6180x-multi 1.0.2
Multiple VL6180X time of flight distance sensors on the same I2C bus.
Requires Python: >=3.6

# __Multiple VL6180X sensors on the same I2C bus__

# Introduction

This module allows operating several VL6180X Time Of Flight sensors on the same I2C bus. This is achieved by reallocating each sensor' address.
The project is intended to run on RaspberryPi. Specifically, it was tested on RaspberryPi 4 with Python 3.7

# Prerequisites
The example below is using Raspberry PI default I2C bus and two GPIOs to control two sensors:

<img src="images/connections.png">

# Running the example
1. Clone the repository:
```bash
git clone https://gitlab.com/vitus133/vl6180x_multi && cd vl6180x_multi
```
2. Create and activate Python virtual environment, install dependencies:
```bash
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

```
3. Install the package
```bash
pip install -e .
```
4. Run the example
```bash
cd example/
python range.py
```