semvec/pypi-packages huggingface dataset:
sat-ws 3.24.0
API to connect with SAT ws
Requires Python: >=3.6

# SAT WS

> Librería para usar el servicio web del SAT de Descarga Masiva

:us: The documentation of this project is in spanish as this is the natural language for intented audience.

:mexico: La documentación del proyecto está en español porque ese es el lenguaje principal de los usuarios.

Basada en gran parte del proyecto <https://github.com/phpcfdi/sat-ws-descarga-masiva>

Código fuente <https://gitlab.com/HomebrewSoft/sat_ws_api>

Esta librería contiene un cliente (consumidor) del servicio del SAT de
**Servicio Web de Descarga Masiva de CFDI y Retenciones**.

## Instalación

<!-- TODO -->

## Ejemplo básico de uso

<!-- TODO -->

## Acerca del Servicio Web de Descarga Masiva de CFDI y Retenciones

El servicio se compone de 4 partes:

1. Autenticación: Esto se hace con tu fiel y la libería oculta la lógica de obtener y usar el Token.
2. Solicitud: Presentar una solicitud incluyendo la fecha de inicio, fecha de fin, tipo de solicitud
   emitidas/recibidas y tipo de información solicitada (cfdi o metadata).
3. Verificación: pregunta al SAT si ya tiene disponible la solicitud.
4. Descargar los paquetes emitidos por la solicitud.

## Compatilibilidad

<!-- TODO -->

## Contribuciones

Las contribuciones con bienvenidas. Por favor lee [CONTRIBUTING][] para más detalles
y recuerda revisar el archivo de tareas pendientes [TODO][] y el [CHANGELOG][].

## Copyright and License

The `sat-ws` library is copyright © [HomebrewSoft](https://homebrewsoft.dev)
and licensed for use under the MIT License (MIT). Please see [LICENSE][] for more information.
djazz-cc 0.1.0rc2
A ready-to-use Django project tailored for practical, real-world applications, djazz comes with pre-configured essential settings and industry best practices built-in, ensuring a streamlined development process right out of the box. Ideal for developers looking to jumpstart their projects without the hassle of initial setup.
Keywords: django, djazz, rest, api, json, serializer, django-rest-framework, drf, django-rest-framework-json-api, json-api, jsonapi, json-api-serializer, json-api

# djazz!

A ready-to-use Django project tailored for practical, real-world applications, djazz comes with pre-configured essential
settings and industry best practices built-in, ensuring a streamlined development process right out of the box. Ideal
for developers looking to jumpstart their projects without the hassle of initial setup.

## Features

- **Django ^5.0.**: The latest version of Django, the web framework for perfectionists with deadlines.
- **PostgreSQL**: The world's most advanced open-source relational database.
- **Powered by Docker**: Dockerized development environment for easy setup and deployment.
- **Built-in User Authentication and Authorization**: Fully functional user authentication and authorization system
  included.
- **Custom User Model**: A custom user model is provided out of the box.
- **Built-in API**: A RESTful API (both django rest framework and django ninja) is included for easy integration with
  frontend frameworks.
- **Django Debug Toolbar**: For easy debugging and performance optimization.
- **And much more!**

## Quick Start

### Experience `djazz` in production ? 🚀

- **[Live Demo](#)** - Coming soon! 🚧
- **[Documentation](#)** - Coming soon! 🚧
- **[Download Latest Release](#)** - Coming soon! 🚧
- **[Report a Bug](https://github.com/azataiot/djazz/issues)** - Open an issue if you find a bug. 🐞
- **[Request a Feature](https://github.com/azataiot/djazz/issues)** - Open an issue if you want to request a feature. 🚀
- **[Contribute](https://github.com/azataiot/djazz/issues)** - Open a pull request if you want to contribute. 🎉

### Local Development

1. Star (⭐️) and Fork 🍴 the repository.
2. Clone the repository.
    ```bash
    git clone <your-github-username> djazz
    ```
3. Change the directory.
    ```bash
    cd djazz
    ```
4. Create a new virtual environment.
    ```bash
    python -m venv venv
    ```
5. Activate the virtual environment.
    ```bash
    source venv/bin/activate
    ```
6. Install the dependencies.
    ```bash
    pip install -r requirements.txt
    ```
7. Run the PostgreSQL and Redis services using Docker.
    ```bash
    docker-compose up -d
    ```
8. Apply the migrations.
    ```bash
    python manage.py migrate
    ```
9. Run the development server.
   ```bash
   python manage.py runserver
   ```
10. Open the browser and visit `http://localhost:8000/`.
11. You're all set! 🚀
quantile-glasses 0.1
A simple python package to correct the issue of quantile crossing in probabilistic forecasting
Requires Python: >=3.9

:eyeglasses: :eyeglasses: :eyeglasses:
# quantile-glasses
A simple python package to correct the issue of quantile crossing in probabilistic forecasting. Kind of like wearing glasses if you can't see well!

The `LinearQuantileGlasses` class allows you to correct your probabilistic forecast and remove quantile crossing.
It works by applying linear optimization, imposing a constraint that quantile crossing does not happen while minimizing [pinball loss](https://www.lokad.com/pinball-loss-function-definition/) on the training set. 

### Installation
Just run 
```bash
pip install quantile-glasses
```
You might encounter a few difficulties installing dependencies for `cvxpy`. If that happens to be the case, install `cvxpy` without dependencies first by running:
```bash
pip install cvxpy --no-deps
```
You can then selectively install the dependencies for that package one at a time. Note that `cvxpy` can work without most dependencies as long as you select a solver that you have installed. See the getting started guide below for an example.

### Getting started
```python
import pandas as pd
import numpy as np
from quantile_glasses import LinearQuantileGlasses

# simulate an independent and dependent variable for a regression problem
x = pd.Series(np.sin(np.linspace(0, 4 * np.pi, 1100)))
y = 5 * x + np.random.randn(len(x))

# define quantiles
quantiles = np.linspace(0.05, 0.95, 5)

# create a simple quantile forecast by binning the data
y_quant = pd.DataFrame(
    {
        q: y.groupby(pd.cut(x, 10), observed=True).transform(lambda x: x.quantile(q))
        for q in quantiles
    }
)

# split data
x_train, x_test = y_quant.iloc[:1000].copy(), y_quant.iloc[-100:].copy()
y_train, y_test = y.iloc[:1000].copy(), y.iloc[-100:].copy()

# artificially switch around the order of some quantiles
quant_switch = x_test.sample(10).index
for i in quant_switch:
    x_test.loc[i] = x_test.loc[i].sort_values(ascending=False).values

# apply correction to prediction
qlg = LinearQuantileGlasses()
y_quant_corr = qlg.fit_predict(x_train, y_train, x_test, solver="CLARABEL")

print("Pinball loss with quantile crossing", qlg.pinball_loss(x_test, y_test).mean())
print(
    "Pinball loss without quantile crossing",
    qlg.pinball_loss(y_quant_corr, y_test).mean(),
)
```