semvec/pypi-packages huggingface dataset:
exif-database 0.1.1
Dump pictures metadata into a MongoDB database for statistics purposes
Requires Python: >=3.8

# exif-database

Dump pictures metadata into a MongoDB database for statistics purpose

## How does it work?

This script works by scanning all files in given directory and then serialize the EXIF metadata to push them
into a MongoDB instances.

## Installation

This package is available on PyPi. You can install it using pip.

```
$ pip install exif-database
```

## Configuration

No configuration is needed. You only need to set up a MongoDB server with a dedicated collection and user
in order for the script to save the data.

[More information](https://docs.bitnami.com/aws/infrastructure/mean/configuration/create-database/).

Note: A docker compose file is provided with this repository but is only used to set up a dev environment easily.

## Executing the script(s)

This package provides two binaries:

### exif-database

This is the main binary, the one used to parse the EXIF and send them to MongoDB.

```
$ MONGO_URI=mongodb://user:pass@server/db python3 -m exif_database <path to images dir>
```

### exif-database.exiftool

This tool parse EXIF metadata of given file and output them to stdout.

```
$ python3 -m exif_database.exiftool <path to image file>
```
FracGrad 0.1.2
Fractional derivatives based gradient descent optimizers for PyTorch
Requires Python: >=3.6


# Fractional Gradient Descent Optimizers for PyTorch

This package implements a novel approach to gradient descent by incorporating fractional derivatives into the update rules of popular optimization algorithms. Built on top of PyTorch, the optimizers in this package (SGD, AdaGrad, RMSProp, and Adam) can leverage both CPU and CUDA devices, making them versatile for a wide range of applications.

## Overview

Fractional derivatives extend the traditional concept of differentiation, offering a more generalized framework that can capture memory and hereditary properties of complex systems. In this package, a custom fractional gradient operator is provided that modifies the gradient computation based on a user-defined fractional order (alpha). This operator can be optionally integrated into any of the available optimizers, allowing for experimental research into fractional gradient descent methods.

## Features

- **Multiple Optimizers:** Custom implementations for SGD, AdaGrad, RMSProp, and Adam.

- **Fractional Derivative Operator:** Modify gradient updates using a fractional derivative, with an adjustable parameter alpha.

- **Seamless Integration:** Easily swap between standard and fractional gradient descent by providing (or omitting) the operator.

- **PyTorch-Based:** Built on top of PyTorch, ensuring compatibility with existing models and the autograd system.

- **CPU and CUDA Support:** Run your experiments on both CPU and GPU.

## Installation

Ensure you have PyTorch installed. You can install PyTorch by following the instructions at [PyTorch.org](https://pytorch.org/).

Clone this repository and add it to your Python path:
```bash
pip install FracGrad
```

## Usage

To use the fractional optimizers, import the desired optimizer and the fractional operator, then pass your model parameters and operator to the optimizer.

### Example

```python
import torch
import torch.nn as nn
import torch.nn.functional as F
from FracGrad import SGD, AdaGrad, RMSProp, Adam
from operators import fractional

# Define a simple model
model = nn.Linear(10, 1)

# Choose a fractional operator with a specific order (alpha)
frac_operator = fractional(alpha=0.9)

# Initialize an optimizer; here we use SGD with the fractional operator
optimizer = SGD(model.parameters(), operator=frac_operator, lr=0.03)

# Training loop example
for data, target in dataloader:
    optimizer.zero_grad()
    output = model(data)
    loss = F.mse_loss(output, target)
    loss.backward()
    optimizer.step()

```

## File Structure

- **operators.py:** Contains the implementation of the fractional class, which defines the fractional derivative operator. This operator adjusts the gradient based on the fractional order.

- **optimizers.py:** Implements custom versions of standard optimizers (SGD, AdaGrad, RMSProp, and Adam). Each optimizer is designed to optionally use the fractional operator for modified gradient updates.

## Contributing

Contributions, suggestions, and bug reports are welcome! Feel free to open an issue or submit a pull request.
SankeyExcelParser 1.0.0b1
Excel Parser for OpenSankey suite

# SankeyExcelParser 

## Description
This package allows to parse excel file with a specific format (todo format link) and instantiate a class Sankey which can be used by other applications.
There are two at this time:
- OpenSankey publicly available at https://gitlab.com/terriflux-public/OpenSankey
- SCMFA wich is a private application commercialized by TerriFlux (terriflux.fr) which is running on app.terriflux.fr

## Installation

### Executable
- Available on https://pypi.org/project/SankeyExcelParser/
- To install pip install SankeyExcelParser

### Repository
- git clone https://gitlab.com/su-model/sankeyexcelparser.git SankeyExcelParser

## Run it

## Test it

## Integrate with your tools

- To write
selectml 0.1.1
A streamlined pipeline for model selection, data preprocessing, training, and evaluation
Requires Python: >=3.6

# SelectML

**SelectML** is an allâ€‘inâ€‘one pipeline for model selection, data preprocessing, training, and evaluation tailored for classification tasks. Designed for data scientists, it streamlines the process of choosing the most suitable model without requiring additional imports.

## Features

- **Data Preprocessing:** Automatic scaling and oneâ€‘hot encoding.
- **Model Selection:** Choose between logistic regression, random forest, or SVM.
- **Integrated Pipeline:** Automatically split data, train models, and evaluate performance.

## Installation

Install via pip (after publishing):

```bash
pip install selectml
```

## Quick Start
```python
import pandas as pd
from selectml import ModelSelectionPipeline

# Sample dataset
data = {
    'age': [25, 32, 47, 51, 23, 45, 36, 29],
    'income': [50000, 60000, 80000, 90000, 40000, 75000, 65000, 55000],
    'city': ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix', 'Philadelphia', 'San Antonio', 'San Diego'],
    'purchased': [0, 1, 0, 1, 0, 1, 1, 0]
}
df = pd.DataFrame(data)

numerical_features = ['age', 'income']
categorical_features = ['city']

# Initialize pipeline with desired model type
pipeline = ModelSelectionPipeline(model_type='random_forest')
result = pipeline.run_pipeline(df, target='purchased', 
                               numerical_features=numerical_features, 
                               categorical_features=categorical_features)

print("Accuracy:", result['accuracy'])
print("Classification Report:\n", result['report'])
```

## License
This project is licensed under the MIT License.
tiny-api-client 1.4.0
The short and sweet way to create an API client
Requires Python: >=3.10

# Tiny API Client 🐝

[![License: GPL  v2][license-shield]][gnu]

Write JSON API Clients in Python without the fluff, pumped full of
syntactic sugar

```python
from tiny_api_client import api_client, get, post, delete

@api_client('https://example.org/api/public/v{version}')
class MyAPIClient:
	@get('/users/{user_id}')
	def find_user(self, response):
		return response

	@post('/notes')
	def create_note(self, response):
		return response

	@delete('/notes/{note_id}/attachment/{attachment_id}', version=3)
	def delete_note_attachment(self, response):
		return response

>>> client = MyClient()
>>> client.find_user(user_id='PeterParker')
{'name': 'Peter', 'surname': 'Parker', ...}
>>> client.create_note(data={'title': 'New Note', 'content': 'Hello World!'})
{'id': ...}
>>> client.delete_note_attachment(node_id=...)
```



## Features

- Instance-scoped `requests.Session()` with connection pooling and
  cookie preservation
- JSON is king, but XML and raw responses are fine too
- Endpoints can use GET, POST, PUT, PATCH, DELETE
- Route parameters are optional
- Easy integration with your custom API classes
- Declare endpoints under different API versions
- Can define the API URL at runtime if not available before
- Can set a custom CookieJar to pass with all requests
- Pass along any parameters you would usually pass to requests
- Custom JSON status error handling
- Installable [pytest plugin][pytest-plugin] for easy testing
- Excellent support for type checking thanks to a built-in mypy plugin



## Installation

```bash
pip install tiny-api-client
```



## Documentation

You can find the documentation at
https://tiny-api-client.readthedocs.io



## License

[![License: LGPL  v2.1][license-shield]][gnu]

This software is distributed under the
[Lesser General Public License v2.1][license],
more information available at the [Free Software Foundation][gnu].



<!-- LINKS -->

[pytest-plugin]: https://github.com/sanjacob/pytest-tiny-api-client



<!-- LICENSE -->

[license]: LICENSE "Lesser General Public License v2.1"
[gnu]: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html "Free Software Foundation"
[license-shield]: https://img.shields.io/github/license/sanjacob/tiny-api-client



<!-- SHIELD LINKS -->

[pypi]: https://pypi.org/project/tiny-api-client



<!-- SHIELDS -->

[pypi-shield]: https://img.shields.io/pypi/v/tiny-api-client
[build-shield]: https://img.shields.io/github/actions/workflow/status/sanjacob/tiny-api-client/build.yml?branch=master
[docs-shield]: https://img.shields.io/readthedocs/tiny-api-client
sphinxcontrib-sass 0.3.5
Sphinx extension to compile sass to css in running sphinx-build.

==================
sphinxcontrib-sass
==================

Overview
========

Sphinx extension to compile sass to css in running sphinx-build.

Install
=======

.. code-block:: bash

   pip install sphinxcontrib-sass

Usage
=====

#. Install from source
#. Edit ``conf.py``

   * Set ``sphinxcontrib.sass`` into ``extensions``
   * Configure for ``sphinxcontrib.sass`` (see example)
#. Run ``sphinx-build``

Options
-------

``sass_src_dir``
  Root directory of SASS source files.

``sass_out_dir``
  Root directory to output compiled css files.

``sass_targets``
  File map of sources and outputs

``sass_output_style``
  Output style to generate css by libsass.

``sass_include_paths``
  Include path configuration for libsass.

Example
=======

.. code-block:: python

   extensions = [
       "sphinxcontrib.sass",
   ]
   html_css_files = ["css/custom.css"]

   sass_src_dir = "_sass"
   sass_out_dir = "_static/css"
   sass_targets = {
    "custom.scss": "custom.css"
   }

License
=======

Apache 2.0. See `it <./LICENSE>`_.