semvec/pypi-packages huggingface dataset:
bstruct 0.6.1
Simple and efficient binary (de)serialization using type annotations.
License: MIT
Requires Python: >=3.9,<4.0

# bstruct

[![ci](https://github.com/flxbe/bstruct/actions/workflows/ci.yml/badge.svg)](https://github.com/flxbe/bstruct/actions/workflows/ci.yml)
[![pypi](https://img.shields.io/pypi/v/bstruct)](https://pypi.org/project/bstruct/)
[![python](https://img.shields.io/pypi/pyversions/bstruct)](https://img.shields.io/pypi/pyversions/bstruct)

<!-- start elevator-pitch -->

Simple and efficient binary (de)serialization using type annotations.
Supports easy fallback to Python's built-in `struct` library for maximum performance.

<!-- end elevator-pitch -->

## Getting Started

<!-- start quickstart -->

```bash
pip install bstruct
```

```python
from typing import Annotated
from dataclasses import dataclass

import bstruct


@dataclass
class Measurement:
    timestamp: bstruct.u32  # shorthand for: Annotated[int, bstruct.Encodings.u32]
    values: Annotated[list[bstruct.u8], bstruct.Array(3)]


MeasurementEncoding = bstruct.derive(Measurement)


measurement = Measurement(
    timestamp=1672764049,
    values=[1, 2, 3],
)

encoded = MeasurementEncoding.encode(measurement)
decoded = MeasurementEncoding.decode(encoded)

assert decoded == measurement
```

<!-- end quickstart -->

See the [documentation](https://bstruct.readthedocs.io/) for more information.

## Benchmarks

Please see the source of the benchmarks in the `benchmarks` directory.
Feel free to create an issue or PR should there be a problem with the methodology.
The benchmarks where executed with
[pyperf](https://github.com/psf/pyperf)
using Python 3.11.1 and
[construct](https://pypi.org/project/construct/) 2.10.68
on a MacBook Pro 2018 with a 2.3GHz i5 processor.

### `benchmarks/builtins.py`

| Name                 | decode  | encode   |
| -------------------- | ------- | -------- |
| struct               | 0.54 us | 0.23 us  |
| bstruct              | 2.51 us | 1.64 us  |
| construct (compiled) | 9.49 us | 10.00 us |

### `benchmarks/native_list.py`

| Name                 | decode  | encode  |
| -------------------- | ------- | ------- |
| struct               | 0.17 us | 0.33 us |
| bstruct              | 1.70 us | 0.59 us |
| construct (compiled) | 4.04 us | 6.61 us |

### `benchmarks/class_list.py`

| Name                 | decode  | encode  |
| -------------------- | ------- | ------- |
| bstruct              | 7.37 us | 4.81 us |
| construct (compiled) | 34.5 us | 36.6 us |

### `benchmarks/nested.py`

| Name                 | decode  | encode  |
| -------------------- | ------- | ------- |
| bstruct              | 6.05 us | 4.42 us |
| construct (compiled) | 27.6 us | 29.5 us |

## Issues and Contributing

I am very happy to receive any kind of feedback or contribution.
Just open an issue and let me know.
ajuste-ebo 0.1.1
Libreria para realizar ajustes de curva con 3 tipos de         kernels, gaussiano, tricube , Epanechnikov
License: MIT
Requires Python: >=3.10.12

# Librería de Ajuste de Curva con Kernels en Python

Esta librería proporciona herramientas para realizar ajustes de curva utilizando tres tipos de kernels: gaussiano, tricube y Epanechnikov. Los ajustes de curva son útiles en estadística y análisis de datos para modelar relaciones entre variables.

## Instalación

Puedes instalar la librería usando `pip`:

```bash
pip install ajuste_ebo
kernelO 0.0.1
Esta libreria se encarga de realizar el analisis de datos usando un kernel gaussiano, trucube y Epanechnikov
License: MIT
Requires Python: >=3.10.12

## Kernel

Esta librería contiene las funciones que se encargan de realizar ajustes usando tres tipos de kernels:

* kernel gaussiano
* kernel Tricube
* kernel Epachinechnikov

Para usar la librería es necesario pasar la dirrección a un archivo csv que se encuentre en el entorno local.
allkernAna 0.1.0
libreria de suavizado con kernell gausiano, tricube y Epanechikov
License: MIT
Requires Python: >=3.7.2

# Suavizado con kernel gaussiano

Esta libreria realiza una grÃ¡fica del suavizado de una funciÃ³n cuando se grafican los datos del nÃºmero de casos cada dÃ­a durante la pandemia del Covid-19.
GTAlib-KernelAdjust 0.1.0
Libreria para el ajuste de datos utilizando distintos kernels
License: MIT
Requires Python: >=3.11.6

# DataAdjustment

`DataAdjustment` es una clase Python que proporciona funcionalidades para el ajuste de datos utilizando el metodo de Kernels. El proceso de suavizaciÃ³n se hace mediante tres tipos de kernel: Gaussiano, Tricube y Epanechnikov 

## Requisitos

- Python 3.11.6
- numpy 1.26.1
- pandas 2.1.2
- matplotlib 3.8.1



## Instalacion

Para instalar la libreria, utiliza el comando

```bash
pip install GTAlib_KernelAdjust
```


## Uso
La estructura base para implementar la libreria es:

```python
# Importar la clase DataAdjustment
from GTAlib_KernelAdjust import Kernels_DataAdjust

# Crear una instancia de DataAdjustment con el URD del archivo CSV de datos y valor de sigma (opcional)
adjustment = Kernels_DataAdjust('datos.csv', sigma=1)

# Graficar la curva suavizada junto con los datos reales usando cada uno de los Kernels
adjustment.plot_smooth_curves()

# Graficar la comparativa de Kernels 
adjustment.comparison()
```
kernelparcial 0.1.0
library ML
License: MIT
Requires Python: >=3.10.12

# Kernels

Esta es una clase de Python que implementa el kernel gaussiano, kernel tricúbico y kernel Epanechnikov para suavizar una serie de tiempo. Esta clase permite cargar datos desde un archivo CSV, suavizar la serie de tiempo y graficar tanto la serie original como la suavizada.

## Requisitos

Asegúrate de tener instaladas las siguientes bibliotecas antes de utilizar esta clase:

- pandas
- numpy
- matplotlib

Puedes instalarlas utilizando `pip`:

```bash
pip install pandas numpy matplotlib
```

## Uso

```python
from kernelparcial import Kernels

# Inicializa la clase con la ruta del archivo CSV y el valor de sigma (parámetro de suavizado)
kernels = Kernels("archivo.csv", sigma)

# Grafica la serie de tiempo original y suavizada con el Kernel Gaussiano.
kernels.PlotGaussianKernel()

# Grafica la serie de tiempo original y suavizada con el Kernel Tricúbico .
kernels.PlotTricubeKernel()

# Grafica la serie de tiempo original y suavizada con el Kernel Epanechnikov.
kernels.PlotEpanechnikovKernel()

#Grafica la serie de tiempo original y la suavizada con los Kernel Gaussianos, Tricúbico y Epanechnikov.
kernels.PlotAllKernels()
```

## Parámetros

- `data` (str): Ruta del archivo CSV con los datos de la serie de tiempo.
- `sigma` (float): Parámetro de suavizado.

Nota: El archivo CSV debe contener dos columnas con los nombres 'fecha_actualizacion' y 'nuevos_casos' para que esta clase funcione correctamente.

## Ejemplo

```python
kernel = KernelGaussiano("datos_covid.csv", 3.0)
kernel.PlotAllKernels()
```

## Créditos

Esta librería fue desarrollada por Luciano Muñoz.

## Contacto

Si tienes alguna pregunta o comentario, no dudes en ponerte en contacto conmigo a través de mi correo electrónico: [luciano.munoz1@udea.edu.co].