semvec/pypi-packages huggingface dataset:
daisyui-components-django 0.0.1a0
Reusable daisyUI components with django-components
Requires Python: >=3.10

# django-components-daisyui

Reusable DaisyUI v5 components for Django using django-components.

## Installation

```bash
pip install daisyui-components-django
```

## Requirements

- Python >= 3.10
- Django >= 5.0
- django-components >= 0.25
luasense 0.5.0
Intelligent autocompletion for Lua scripting language
Requires Python: >=3.9
Keywords: autocomplete, completion, lua, intellisense

# LuaSense

A Python library providing intelligent autocompletion for Lua scripting language keywords and built-in functions.

## Features

- Fast, case-sensitive autocompletion for Lua keywords and functions
- Input validation with meaningful error messages
- Zero external dependencies
- Fully typed for better IDE support

## Installation

```bash
pip install luasense
```

## Usage

```python
import luasense

# Get autocomplete suggestions
try:
    suggestions = luasense.autocomplete("pri")
    print(suggestions)  # ['print', 'private']
except luasense.TooShortRequestError:
    print("Input too short - minimum 2 characters required")
```

## API

autocomplete(query: str) -> List[str]

Returns a list of Lua keywords and built-in functions that start with the given query.

· query: String to autocomplete (minimum 2 characters)
· Returns: List of matching Lua identifiers
· Raises: TooShortRequestError if query length < 2

## License

Apache-2.0
luausense 0.5.0
Intelligent autocompletion for Luau scripting language
Requires Python: >=3.9
Keywords: autocomplete, completion, lua, intellisense, luau, roblox

# LuauSense

A Python library providing intelligent autocompletion for Luau scripting language keywords and built-in functions.

## Features

- Fast, case-sensitive autocompletion for Luau keywords and functions
- Input validation with meaningful error messages
- Zero external dependencies
- Fully typed for better IDE support

## Installation

```bash
pip install luausense
```

## Usage

```python
import luausense

# Get autocomplete suggestions
try:
    suggestions = luausense.autocomplete("pri")
    print(suggestions)  # ['print', 'private']
except luausense.TooShortRequestError:
    print("Input too short - minimum 2 characters required")
```

## API

autocomplete(query: str) -> List[str]

Returns a list of Luau keywords and built-in functions that start with the given query.

· query: String to autocomplete (minimum 2 characters)
· Returns: List of matching Luau identifiers
· Raises: TooShortRequestError if query length < 2

## License

Apache-2.0
pydal2sql-core 0.5.1
CLI-agnostic pydal2sql code; Convert pydal define_tables to SQL using pydal's CREATE TABLE logic.
Requires Python: >=3.10
Keywords: databases, pydal, sql

# pydal2sql-core

[![PyPI - Version](https://img.shields.io/pypi/v/pydal2sql-core.svg)](https://pypi.org/project/pydal2sql-core)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pydal2sql-core.svg)](https://pypi.org/project/pydal2sql-core)  
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)  
[![su6 checks](https://github.com/robinvandernoord/pydal2sql-core/actions/workflows/su6.yml/badge.svg?branch=development)](https://github.com/robinvandernoord/pydal2sql-core/actions)
![coverage.svg](coverage.svg)

-----

Companion library for [`pydal2sql`](https://github.com/robinvandernoord/pydal2sql) containing the actual logic.
The other library only serves as a Typer-based CLI front-end.

_More Documentation coming soon!_

## Table of Contents

- [Installation](#installation)
- [As a Python Library](#as-a-python-library)
- [License](#license)

## Installation

```bash
pip install pydal2sql-core
```

## As a Python Library

`pydal2sql-core` also exposes a `generate_sql` method that can perform the same actions on one (for CREATE) or two (for
ALTER) `pydal.Table` objects when used within Python.

```python
from pydal import DAL, Field
from pydal2sql_core import generate_sql

db = DAL(None, migrate=False)  # <- without running database or with a different type of database

person_initial = db.define_table(
    "person",
    Field(
        "name",
        "string",
        notnull=True,
    ),
    Field("age", "integer", default=18),
    Field("float", "decimal(2,3)"),
    Field("nicknames", "list:string"),
    Field("obj", "json"),
)

print(
    generate_sql(
        db.person, db_type="psql"  # or sqlite, or mysql; Optional with fallback to currently using database type.
    )
)
```

```sql
CREATE TABLE person
(
    id        INTEGER PRIMARY KEY AUTOINCREMENT,
    name      VARCHAR(512),
    age       INTEGER,
    float     NUMERIC(2, 3),
    nicknames TEXT,
    obj       TEXT
);
```

```python
person_new = db.define_table(
    "person",
    Field(
        "name",
        "text",
    ),
    Field("birthday", "datetime"),
    redefine=True
)

generate_sql(
    person_initial,
    person_new,
    db_type="psql"
)
```

```sql
ALTER TABLE person
    ADD "name__tmp" TEXT;
UPDATE person
SET "name__tmp"=name;
ALTER TABLE person DROP COLUMN name;
ALTER TABLE person
    ADD name TEXT;
UPDATE person
SET name="name__tmp";
ALTER TABLE person DROP COLUMN "name__tmp";
ALTER TABLE person
    ADD birthday TIMESTAMP;
ALTER TABLE person DROP COLUMN age;
ALTER TABLE person DROP COLUMN float;
ALTER TABLE person DROP COLUMN nicknames;
ALTER TABLE person DROP COLUMN obj;
```

## License

`pydal2sql-core` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
ootools-oocli 0.3.0
A command line interface for running cloud jobs
Requires Python: >=3.11

# o-o

**o&#8209;o** is a command line interface for running jobs on ephemeral
cloud instances with tracked inputs and outputs. Building data or MLOps
pipelines is as simple as stringing together multiple commands, as easily as
running locally, but with the power of cloud compute and storage.

## Highlights

* Easily run any command in any language in cloud compute environments
* Flexible. Define your own run environments with docker images and machine types
* Traceable. Trace all inputs to the commands that produced them
* You control your data. Data and source code is stored in your managed buckets
* Support for Scaleway and Google Cloud (more to come...)

## Getting Started

Follow the [installation instructions](https://o-o.tools/) to configure
**o-o**. Once setup, define environments and datastores in an `.ooconfig` file:

```yaml
project: test-project
environments:
  scaleway:
    provider: Scaleway
    image: docker.io/debian:stable-slim
    machinetype: STARDUST1-S
    region: fr-par-1
  gcp:
    provider: gcp
    image: docker.io/debian:stable-slim
    machinetype: e2-highcpu-2
    region: northamerica-northeast1-b
datastores:
  my-datastore:
    provider: Scaleway
    bucket: o-o-data
    region: fr-par
```

Lets start with a simple example that creates a `data.txt` file containing
"Hello World" (under the hood, **o-o** will start and configure our `scaleway`
environment, execute our command, copy output files to our datastore, and
finally, delete the Scaleway instance).

```console
$ o-o run --environment scaleway --message "create data.txt" -- \
    'echo "Hello World" > o://output/data.txt'
```

We completed our first run! `o-o run --list` displays the run's id (in this
case `ntus965ryy`) and message:

```console
$ o-o run --list
ntus965ryy create data.txt
```

You are free to run commands in any configured environment. Let's run a second
command in our `gcp` environment that uses the output of `ntus965ryy`
as input, and simply prints the contents of `data.txt`:

```console
$ o-o run --environment gcp --message "print data.txt" -- \
    cat o://ntus965ryy/data.txt
Hello World

$ o-o run --list
ntus965ryy create data.txt
cxdbx8am38 print data.txt
```

And that's the basics. Find out more in the [documentation](https://o-o.tools/)
and with `o-o --help`.
apiMoneyFusion 0.1.4
API pour gérer la transactions dans fusion Money pour python
Requires Python: >=3.6

# API MONEY FUSION PAYEMENT PYTHON

Elle permet d'intéragir avec l'API de paiement de MoneyFusion. Elle facilite la création et la récupération des paiements via des requêtes HTTP.

## Installation

vous pourrez l'installer avec :

```sh
pip install apiMoneyFusion
```

## Utilisation

### Importation

```python
from apiMoneyFusion import PaymentClient
```

### Initialisation du client

```python
client = PaymentClient(api_key_url="YOUR_API_URL")
```

### Créer un paiement

```python
payment = client.create_payment(
    total_price="10000",
    articles=[{"name": "Article 1", "price": "5000", "quantity": 1}],
    numero_send="0101010101",
    nom_client="assemienDev",
    user_id=1,
    order_id=123,
    return_url="https://votre-domaine.com/callback",
    webhook_url="https://your-domain.com/my-webhook-url",
)

print(payment)
```
NB: webhook_url doit accepter les requêtes POST

Réponse attendue :

```json
{
    "statut": true,
    "token": "f5EJ33JYmxqosi8BvaEt",
    "message": "paiement en cours",
    "url": "https://www.pay.moneyfusion.net/pay/f5EJ33JYmxqosi8BvaEt"
}
```

### Récupérer un paiement

```python
payment_info = client.get_payment("8L5teSc5TaIkP3ds9Dlx")
print(payment_info)
```

Réponse attendue :

```json
{
    "statut": true,
    "data": {
        "_id": "6748d365967cb4766fdd1616",
        "tokenPay": "8L5teSc5TaIkP3ds9Dlx",
        "numeroSend": "None",
        "nomclient": "assemienDev",
        "personal_Info": [{"userId": 1, "orderId": 123}],
        "numeroTransaction": "",
        "Montant": 475,
        "frais": 25,
        "statut": "paid",
        "moyen": "card",
        "return_url": "https://votre-domaine.com/callback",
        "createdAt": "2024-11-28T20:32:37.037Z"
    },
    "message": "details paiement"
}
```

## Contributions

Les contributions sont les bienvenues ! N'hésitez pas à proposer des améliorations ou signaler des bugs en ouvrant une issue sur GitHub.

## Licence

Ce projet est sous licence MIT. Voir le fichier LICENSE pour plus d'informations.
addok-fr 1.1.0
Addok plugin for French language support with phonetic normalization and French-specific synonyms.
Requires Python: >=3.9
Keywords: addok, geocoding, french, plugin

# addok-fr

Addok plugin for improved French geocoding with phonetic normalization and French-specific synonym handling.

## Features

- **Phonetic normalization**: French-optimized phonetic processor that handles typos and spelling variations in address searches
- **French synonyms**: Pre-configured synonym database for common French address terms (rue, avenue, boulevard, etc.)

## Installation

    pip install addok-fr


## Configuration

### Enable the phonemicize processor

Add `phonemicize` into PROCESSORS_PYPATHS:

```python
PROCESSORS_PYPATHS = [
    …,
    'addok_fr.phonemicize'
]
```

### Cache configuration (optional)

The phonemicize processor uses an LRU cache to improve performance. By default, the cache can hold up to 500,000 entries (~86 MB of memory), which is suitable for approximately 500,000 unique words.

You can adjust the cache size in your Addok configuration file:

```python
PHONEMICIZE_CACHE_SIZE = 500_000  # Default value
```

**Recommendations:**
- **500K entries** (~86 MB): Default, suitable for most French address datasets
- **1M entries** (~172 MB): For larger datasets with more unique words
- **250K entries** (~43 MB): For memory-constrained environments

The cache uses an LRU (Least Recently Used) eviction strategy, meaning the most frequently used words will remain cached even if the maximum size is reached