semvec/pypi-packages huggingface dataset:
pyshs 0.3.9
PySHS - Faciliter le traitement de données de questionnaires en SHS
Requires Python: >=3.7

# PySHS : traitement de données en sciences sociales avec Python

La bibliothèque PySHS a pour but de faciliter l'analyse de données avec Python de questionnaire en sciences humaines et sociales pour les francophones.

Elle vise à combler (partiellement) le manque de fonctions de traitement de données en Python pour les enquêtes par questionnaires, notamment en comparaison avec R.

## Contenu

### Traiter des données issues d'enquêtes par questionnaires (avec pondération)

- Description d'un tableau de données
- Tri à plat et tableau(x) croisé(s) avec pondération
- Régression logistique sous forme d'un tableau simple
- Sauvegarde en format tableur de tableaux
- Importation de la fonction `catdes` de FactoMineR (association variable catégorielle/autres variables)
- Visualisation statique d'une ACM de Prince

N'hésitez pas à compléter :) 

## Installation

### Avec pip

```sh
$ pip install pyshs --upgrade
```

### Version de développement

```sh
$ git clone https://github.com/emilienschultz/pyshs-bib.git
$ cd pyshs
$ pip install -e .
```

## Utilisation

### Tri à plat d'une variable qualitative pondérée

```python
>> import pyshs
>> data = pd.read_excel("enquete.xlsx")
>> pyshs.tri_a_plat(data,"age","weight")
```

| age     |   Effectif redressé |   Pourcentage (%) |
|:--------|--------------------:|------------------:|
| [0-25[  |               260.4 |              13.0 |
| [25-45[ |               731.1 |              36.5 |
| [45-65[ |               755.1 |              37.7 |
| [65+    |               256.4 |              12.8 |
| Total   |                2003 |               100 |


### Autres utilisations

Voir le Notebook **Exemple PySHS.ipynb** pour voir les fonctions disponibles.
continualcode 0.6.0
A coding agent that learns from your corrections in real-time via on-policy self-distillation
Requires Python: >=3.10
Keywords: coding-agent, online-learning, sdpo, self-distillation, tinker

# continualcode

A coding agent that learns from your corrections in real-time. Built on [Tinker](https://thinkingmachines.ai/tinker).

When you deny a tool call with feedback, the model uses your correction as context to teach itself via [on-policy self-distillation](https://self-distillation.github.io/SDPO), takes a gradient step on LoRA, and retries with updated weights.

```
You: "fix the test"
Agent: write(test.py, ...)       # overwrites the file
You: n → "use edit_lines; don't overwrite"
  → SDPO update runs immediately
  → agent retries with updated weights
Agent: edit_lines(test.py, 14, 17, ...)
You: y
```

## Install

```bash
pip install continualcode
export TINKER_API_KEY=<your-key>
continualcode
```

## How it works

Four feedback types, one training signal. Your correction becomes privileged context for a self-teacher (same model, richer input). Per-token KL between teacher and student = dense training signal — O(N) bits per correction, not O(1). One gradient step on LoRA, retry with updated weights.

**[Full explanation →](docs/)**

## Why not DPO / GRPO / PPO / SFT

**DPO** needs preference pairs and has no per-token credit. **GRPO** needs 64 samples per prompt — absurd UX for a CLI. **PPO** doubles memory with a critic network. **SFT on corrections** is off-policy and causes catastrophic forgetting. Self-distillation is the unique intersection: dense signal, on-policy, no extra models, mode-seeking stability.

**[Full reasoning →](docs/design.md)**

## Code layout

- `train.py` — SDPO core: teacher prompt, logprob scoring, IS update, sampler refresh
- `tui.py` — interactive CLI: approve/deny/edit, correction prompt, `/metrics`
- `tools.py` — tool implementations + structured feedback
- `benchmarks/auto_train.py` — automated training loop (LCB, multi-rollout GRPO + SDPO)
- `demo/` — deny → train → retry end-to-end

## References

- [SDPO](https://self-distillation.github.io/SDPO) — Hübotter et al. 2026
- [SDFT](https://self-distillation.github.io/SDFT.html) — Shenfeld, Damani, Guestrin 2026
- [GKD](https://arxiv.org/abs/2306.13649) — Agarwal et al. 2023
- [Tinker](https://thinkingmachines.ai/tinker) — training API
elefast 0.1.0a4
Database testing toolkit integrating Postgres, SQLAlchemy, Pytest and Docker
Requires Python: >=3.14

# Elefast 🐘⚡

Using an actual database for testing is nice, but setting everything up can be a pain.
Generating the schema, isolating the state, and supporting parallel execution while keeping everything reasonably quick.
Elefast helps you by providing utilities for all of these tasks

To learn more, visit [the documentation](https://niclasvaneyk.github.io/elefast/getting-started) or run through the quickstart guide below.

## Quickstart

Install the package from PyPi through your package manager

```shell
uv add 'elefast[docker]'
```

add the recommended set of fixtures to your `conftest.py`

```shell
mkdir tests/ && uv run elefast init >> tests/conftest.py
```

create a test using your new set of fixtures

```python
from sqlalchemy import Connection, text

def test_database_math(db_connection: Connection):
    result = db_connection.execute(text("SELECT 1 + 1")).scalar_one()
    assert result == 2
```

When you now run `pytest`, we'll automatically start a Docker container (if one is not already running), and pass a database connection into the test
chronostring 0.1.5
Extracts and structures dates and times from natural French text.
Requires Python: >=3.7

# chronostring

*chronostring* is a Python library designed to extract dates and times from natural language strings written in *French*. It transforms text like "du 3 au 5 juillet" into Python `datetime` objects, making it easier to process temporal information from unstructured data.

It is designed to handle flexible, informal expressions such as:

- "5 et 6 juin 2024"
- "du 3 au 5 juillet"
- "lundi 4 et mardi 5 mars 2025"
- "les 1er, 2 et 5 juin à 10h"
- "le 8 et le 9 mai"
- "vendredi 12/01/2025 à 18h30"

## Features

- Extracts single dates and date ranges from French strings
- Handles time expressions like "à 18h" or "de 10:00 à 12:00"
- Recognizes partial dates and completes them from context
- Produces clean and structured outputs: each item in the output list is either a date, a datetime or a datetime range.

## How chronostring Works

*chronostring* operates through a [multi-step process](./chronostring/chronostring.py) designed for extracting structured date and time data from natural language strings.

First, the input string is [tokenized](./chronostring/tokenizer.py) into elementary [Token](./chronostring/tokens.py) objects, identifying both literal tokens (such as conjunctions and delimiters) and content-bearing ones (such as partial or complete dates and times).

These tokens are then enriched through a second stage that detects and completes partial dates and times when possible. The next stage involves matching token sequences to known temporal patterns, using a symbolic representation (each token class mapped to a character) and applying regular expressions on these symbolic strings.

Matched patterns are replaced with more complex temporal objects such as datetime, date, or datetime intervals.
This entire processing pipeline is implemented via a series of [processors](./chronostring/processors.py), designed to be chained and optimized with Python's yield mechanism for lazy evaluation and efficiency.

The library also supports internationalization: all language-specific tokens and processors for French are grouped into a separate implementation ([tokens_fr](./chronostring/tokens_fr.py) and [processors_fr](./chronostring/processors_fr.py)), making it easy to extend support for other languages.

## Installation

```bash
pip install chronostring
```

## Usage

```python
from chronostring import parse_dates

text = "Les 5, 6 et 7 juin à 10h"
dates = parse_dates(text)

for dt in dates:
    print(dt)
```
## Test suite

To run the test suite, simply use the command `make test` from the root directory of the project. This command will automatically invoke `pytest` and run all unit tests defined in the [tests/](./tests/) directory. Make sure you have the required dependencies installed beforehand.

## License

This project is licensed under the *GNU Affero General Public License v3.0 or later (AGPL-3.0)*.

See [LICENSE](./LICENSE) for details.

## Authors

See [AUTHORS.md](./AUTHORS.md) for the list of contributors.