semvec/pypi-packages huggingface dataset:
cyclic-boosting 1.4.0
Implementation of Cyclic Boosting machine learning algorithms
Requires Python: >=3.8,<3.12

# cyclic-boosting

This package contains the implementation of the machine learning algorithm Cyclic Boosting, which is described in [Cyclic Boosting - an explainable supervised machine learning algorithm](https://arxiv.org/abs/2002.03425) and [Demand Forecasting of Individual Probability Density Functions with Machine Learning](https://arxiv.org/abs/2009.07052).

## Documentation

The documentation can be found [here](https://cyclic-boosting.readthedocs.io/en/latest/).

## Quickstart

```
pip install cyclic-boosting
```

```python
from cyclic_boosting.pipelines import pipeline_CBPoissonRegressor
CB_est = pipeline_CBPoissonRegressor()
CB_est.fit(X_train, y)
yhat = CB_est.predict(X_test)
```

## Usage

It can be used in a [scikit-learn](https://scikit-learn.org/stable/)-like fashion, combining a binning method (e.g., [BinNumberTransformer](https://github.com/Blue-Yonder-OSS/cyclic-boosting/blob/main/cyclic_boosting/binning/bin_number_transformer.py)) with a Cyclic Boosting estimator (find all estimators in the [init](https://github.com/Blue-Yonder-OSS/cyclic-boosting/blob/main/cyclic_boosting/__init__.py)). Usage examples can be found in the [integration tests](https://github.com/Blue-Yonder-OSS/cyclic-boosting/blob/main/tests/test_integration.py).
git-lfs-http-mirror 0.0.7
Simple Python server to serve a read only HTTP mirror of git repositories that use Large File Storage (LFS)
Requires Python: >=3.7.4

# git-lfs-http-mirror

Python wrapper for git that allows it to read a GET-only HTTP mirror of repositories that use Large File Storage (LFS). It effectively extends git's so-called [dumb git protocol](https://git-scm.com/book/en/v2/Git-on-the-Server-The-Protocols#_dumb_http) with the capability to serve LFS files.

This means you can use S3 to host mirrors of LFS repositories, without additional infrastructure. However, no authentication mechanism is currently supported. From the point of view of the calling code, it must be a publically readable bucket.

It works by temporarily firing up an LFS server during the lifetime of the git command.


## Installation

```bash
pip install git-lfs-http-mirror
```


## Usage

Configuration is by command line arguments

```bash
python -m git_lfs_http_mirror
    --upstream-root 'https://my-bucket.s3.eu-west-2.amazonaws.com/a-folder'
    --bind '127.0.0.1:8080'
    -- git clone http://127.0.0.1:8080/my-repo
```

You can make this slightly less verbose my making a wrapper bash script. If the below is in an executable file `glfsm` in your PATH

```bash
#!/usr/bin/env bash

exec python -m git_lfs_http_mirror \
    --upstream-root 'https://my-bucket.s3.eu-west-2.amazonaws.com/a-folder' \
    --bind '127.0.0.1:8080' \
    $@
```

then you can call

```bash
glfsm -- git clone http://127.0.0.1:8080/my-repo
````

The server configued as `upstream_root` should be a static server, serving copies of git repositories, for example S3. Each copy can be created using:

```bash
git clone --bare https://server.test/my-repo
cd my-repo.git
git lfs fetch
git update-server-info
````

and then uploaded to the server in its own folder. If the server is S3, this can be done using the Upload folder feature in the AWS S3 Console.
raebot 0.2.0
A library that fetches definitions from the DLE
Requires Python: >=3.10,<4.0

# raebot

Search for definitions from the DLE.

This package is inspired by [pyrae](https://github.com/nachocho/pyrae), but is implemented in a way I find more
intuitive. Also, most importantly for me, synonym and antonym support.

## Installation

```bash
pip install raebot
```

## Develop

- Install poetry.
- Create a virtual environment
- run `poetry install` to install the dependencies.

TDD recommended. Add a case, then update the script to make the test pass.

PRs welcome.

## Testing

Run `poetry run pytest` to run the tests.

## Publish

If you are Weiwei or one of his robots, run `poetry publish --build` to publish a new version.

## Usage

```python
>>> from raebot import search_words
>>> from pprint import pprint

>>> pprint(search_words('hola'))

[Word(word='lindo, da',
      etymology="Del lat. limpĭdus 'limpio', 'puro'.",
      definitions=[DefinitionX(types=['adj.'],
                               definition='Hermoso, bello, grato a la vista.',
                               examples=[],
                               synonyms=['bonito',
                                         'bello',
                                         'hermoso',
                                         'precioso',
                                         'exquisito',
                                         'agraciado',
                                         'guapo',
                                         'majo'],
                               antonyms=['feo']),
                   DefinitionX(types=['adj.'],
                               definition='Perfecto, primoroso y exquisito.',
                               examples=[],
                               synonyms=[],
                               antonyms=[])],
      phrases=[Phrase(phrase='lindo don Diego',
                      definition=[Definition(types=['m. coloq.', 'desus.'],
                                             definition='lindo (‖ hombre que '
                                                        'presume de guapo).',
                                             examples=[])])])]
```

## Warning

For now it is used by me myself and I for generating anki flashcards. It may never be on feature parity with pyrae. But we shall see.
Reda-Utils 4.0.0
Paquete funciones utiles Navegacion Robot

Autor: REDA KASTITE
version: 4.0.0
Python_version: 2.* & 3.*

Coleccion de funciones. 
    
    Contiene:

    + Funcion lectura de archivo de parametros con formato object y publicacion en param server. [leer_Config()]

    + Funcion lectura de archivo con formato. [leer_Archivo()]

    + Coleccion de metodos para calculo de velocidades en Navegacion Robot. [Nav_utils().[]]

        TODO: DEJAR DE PASAR VELOCIDADES COMO ARGS A LAS FUNCIONES Y COGERLAS DE LOS PARAMETROS

        @ Funciones -------------------------------------------------------------------------------------------------------------

        + cuadrante -> Eleccion de cuadrante segun angulo

        + mixto_diferencial_sin -> Calculo de velocidades angulares de ruedas general. Para robots diferenciales y curvatura de la trayectoria segun angulo usando sin.

        + recto_diferencial -> Calculo de velocidades angulares de ruedas especifico para ir en linea recta (dir=1) o en marcha atras (dir=-1)

        + giro -> Calculo de velocidades angulares de ruedas especifico para giros sobre el propio eje del robot.

        + w_wheels_Twist_diferencial -> Calculo de Velocidad Lineal X y Velocidad Angular Z a partir de las velocidades angulares de las ruedas.

        + vels_a_w -> Calculo de las velocidades angulares de las ruedas a partir  de Velocidad Lineal X y Velocidad Angular Z.

    +