semvec/pypi-packages huggingface dataset:
facture-electronique-sdk 0.1.0
Facturation Electronique SDK est une bibliothèque Python qui simplifie l'interaction avec les principales API de facturation électronique en France, notamment **Chorus Pro**, et d'autres partenaires privés. Elle supporte également le format Factur-X pour la création et l'envoi de factures électroniques.
Requires Python: >=3.6

# Facturation Electronique SDK

## Description
`Facturation Electronique SDK` est une bibliothèque Python qui simplifie l'interaction avec les principales API de facturation électronique en France, notamment **Chorus Pro**, et d'autres partenaires privés. Elle supporte également le format **Factur-X** pour la création et l'envoi de factures électroniques.

Ce SDK est conçu pour être extensible et compatible avec les différentes plateformes de facturation électronique en France, facilitant l'envoi et la gestion des factures en toute conformité avec les réglementations.

## Fonctionnalités
- **Chorus Pro** : Création, envoi et suivi des factures à destination des entités publiques.
- **Factur-X** : Génération de factures au format PDF/Factur-X.

## Installation

1. Clonez ce dépôt ou téléchargez-le :

   ```bash
   git clone https://gitlab.com/cleverip/fr-efact-python-sdk.git
    ```
   
2. Installez les dépendances à l'aide du fichier requirements.txt :
   ```bash
   pip install -r requirements.txt
    ```
## Configuration

Vous devez fournir vos clés API et les URL des différentes plateformes dans un fichier de configuration ou via des variables d'environnement.

Exemple d'un fichier config.py :
   ```python
from .template_config import *


# Configuration API Chorus Pro
CHORUS_PRO_BASE_URL = 'https://chorus-pro.gouv.fr/api'
CHORUS_PRO_API_KEY = 'votre-api-key-chorus-pro'

# Configuration API DPGF
DPGF_BASE_URL = 'https://dpgf-partenaire.fr/api'
DPGF_API_KEY = 'votre-api-key-dpgf'

# Autres configurations...
   ```

## Utilisation

Voir le script api/chorus_pro.py

## Contribution
Si vous souhaitez contribuer à ce projet, veuillez suivre les étapes suivantes :

    Clonez le dépôt.
    Créez une branche pour votre fonctionnalité : git checkout -b nouvelle-fonctionnalité.
    Faites vos modifications et testez-les.
    Soumettez une merge request.

## Licence
Ce projet est sous licence MIT.

## Auteur
Developpé par Thierry Martin
tela 0.2.2
The official Python library for the Tela API
Requires Python: <4.0,>=3.10

# Tela SDK for Python

The Tela SDK for Python provides a simple and powerful way to interact with the Tela API. This SDK allows you to create chat completions, handle file uploads, and manage various resources with ease.

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
- [Examples](#examples)
  - [Simple Completion](#simple-completion)
  - [Chat Completion](#chat-completion)
  - [Webhook Completion](#webhook-completion)
  - [Streaming Completion](#streaming-completion)
- [API Reference](#api-reference)
- [Contributing](#contributing)
- [License](#license)

## Installation

You can install the Tela SDK using pip:

```bash
pip install tela
```

## Usage

First, you need to import the SDK and initialize it with your API key:

```python
from tela import create_tela_client

tela = create_tela_client(api_key='your-api-key')
```

## Examples

### Simple Completion

This example demonstrates how to create a simple completion using a PDF document:

```python
from tela import create_tela_client, create_tela_file

tela = create_tela_client(
    api_key='your-api-key',
)

completion = tela.completions.create({
    canvas_id='your-canvas-id',
    variables={
        "document": create_tela_file("https://www.wmaccess.com/downloads/sample-invoice.pdf"),
    },
})
print(completion)
```

### Chat Completion

This example shows how to create a chat completion with a simple message:

```python
from tela import create_tela_client

tela = create_tela_client(
    api_key='your-api-key',
)
completion = tela.completions.create({
    canvas_id='your-canvas-id',
    messages=[{'role': 'user', 'content': 'Hello!'}],
})
print(completion)
```

### Webhook Completion

This example demonstrates how to create a completion that sends the result to a webhook URL:

```python
from tela import create_tela_client, create_tela_file

tela = create_tela_client(
    api_key='your-api-key',
)

webhook = tela.completions.create({
    canvas_id='your-canvas-id',
    variables={
        document: create_tela_file("https://www.wmaccess.com/downloads/sample-invoice.pdf"),
    },
    webhook_url='https://webhook.site/4294967295',
    stream=False,
})
print(webhook)
```

### Streaming Completion

This example shows how to handle streaming responses:

```python
from tela import create_tela_client, create_tela_file

tela = create_tela_client(
    api_key='your-api-key',
)

with open('sample-invoice.pdf', 'rb') as file:
    completion = tela.completions.create({
        canvas_id='your-canvas-id',
        variables={
            'document': create_tela_file(file),
        },
        stream=True,
    })
    for chunk in completion:
        print(chunk)
```

## Contributing

We welcome contributions to the Tela SDK! Please see our [contributing guide](CONTRIBUTING.md) for more information.
ToBaCco-Modified 3.1.2
Topological MOF generator by molecular block alignment.
Requires Python: >=3.10


# TOBACCO modified version

*Orlando Villegas* - **2024**

Python module tobacco or Topologically Based Crystal Constructor was developed to rapidly produce molecular representations of porous crystals as crystallographic information (.cif) files, which can then be used for molecular simulation or for materials characterization.

This version has as starting point the tobacco_3.0 (https://github.com/tobacco-mofs/tobacco_3.0) version, I have made different modifications to make it executable from command line.

This version keeps the same license (General Public License v3.0) and is modifiable. What I have done is to adapt it to my PostDoc work and share it with the community.

The main use I gave it was as a topological MOF generator. Topological MOF generator by molecular block alignment (ToMOFGen)

## Installation

You can start from a virtual environment local:

```
python -m venv .venv --copies --prompt Tobacco
source .venv/bin/activate
pip install ToBaCco-Modified
```

## Pre-use

Show installation information:

```
pip show tobacco
```

To check that tobacco is installed correctly you can run:

```
tobacco -h
```

Before you can use tobacco you must download the topology database. To do this, execute, this may take a few minutes:

```
tobacco --get_topols_db
```

## Example of uses

To generate a cif file where a block is built with the metal in the center with dummy atoms forming the indicated geometry:

    tobacco -m Sc -pg Oh -d 1.0 -o 6X_Sc.cif


Show available punctual groups.

    tobacco --show_pgs


Generate all available geometries for a metal core:

    tobacco --gen_geometries Sc -d 1.0


Convert `.com` file (Gaussian format) to SBU (Secundary Building Unit) ToBaCco, used to create a structure with dummy atoms to be removed (X-->Fr):

    tobacco --build_sbu node -i 4X_C2.com -o 4X_C2.cif


Method to generate cif files used for edges, and used to preserve the dummy atom:

    tobacco --build_sbu edge -i 2X_SCN.com -X 1 2 -o 2X_SCN.cif


Generate an edge without ligand, X--X. It functions as a connector to more complex topologies.

    tobacco --make_XX_edge


Check if the topology exists:

    tobacco --check_top -t pcu


To generate MOF using ToBaCco:

    tobacco --make_MOF -t pcu


Run using all topologies en Parallel

    tobacco --make_MOF --all_topols --run_parallel

## Remove

For remove tobacco, use:

```
pip uninstall tobacco
```
mcl 0.0.6
Python wrapper for mcl library
Requires Python: >=3.7

# mcl-python

`mcl-python` is a Python library that creates bindings for [mcl](https://github.com/herumi/mcl) library by 光成滋生 MITSUNARI Shigeo(herumi@nifty.com).

## Supported curves

For now the only supported curve is `BLS12_384` (named in library `BN384_256`)

## Installation

**This package requires [mcl](https://github.com/herumi/mcl) to be preinstalled.**

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install mcl-python.

```bash
pip install mcl
```

## Usage

```python
import mcl

fr = new mcl.Fr()
fr.setByCSPRNG()
```

For more examples, please check [tests](tests/).

## Tests

Tests are written in `unittest`.

```
python3 -m unittest discover tests/
```

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
[MIT](https://choosealicense.com/licenses/mit/)
pycrp 1.0.1
A Python package for securely encrypting and decrypting files with advanced algorithms.

# Crp Encryption Tool 🔐

Welcome to **Pycrp**, a simple yet effective command-line tool for encrypting and decrypting files using symmetric encryption 
**[`Fernet`](https://github.com/pyca/cryptography)**. This tool is designed to protect your files with a key you provide and securely save or retrieve them from encrypted `.crp` files.

## Features ✨
- **Encrypt Files**: Secure your files by encrypting them with a key.
- **Decrypt Files**: Retrieve your encrypted files with the correct key.
- **Simple CLI Interface**: Use easy-to-remember commands to encrypt or decrypt files in bulk.


## Installation ⬇️

To get started:

```bash
pip install pycrp
```

## Usage 🚀

This tool provides two main commands: `enc` to encrypt files and `dec` to decrypt them.

### Encrypt Files 🔒

To encrypt files in a directory, use the `enc` command:

```bash
pycrp enc <key> -d <directory> -ex <export_directory>
```

- `<key>`: The encryption key.
- `-d <directory>`: The directory where the files to encrypt are located. If omitted, it defaults to the current directory.
- `-ex <export_directory>`: The directory where the encrypted `.crp` files will be saved. If omitted, it defaults to `crp-files/`.

Example:

```bash
pycrp enc "my-secret-key" -d ./myfiles -ex ./encrypted-files
```

### Decrypt Files 🔓

To decrypt previously encrypted `.crp` files, use the `dec` command:

```bash
pycrp dec <key> -d <directory> -ex <export_directory>
```

- `<key>`: The decryption key (must be the same key used to encrypt the files).
- `-d <directory>`: The directory where the `.crp` files are located. Defaults to the current directory if omitted.
- `-ex <export_directory>`: The directory where the decrypted files will be saved. Defaults to `files/`.

Example:

```bash
pycrp dec "my-secret-key" -d ./encrypted-files -ex ./decrypted-files
```


## Code Overview 🛠️

### `Crp` Class

The `Crp` class provides all the core functionality:

- **`__init__(key: str)`**: Initializes the encryption/decryption object with a specified key.
- **`encrypt( bytes) -> bytes`**: Encrypts byte data using the Fernet symmetric encryption.
- **`decrypt( bytes) -> bytes`**: Decrypts previously encrypted byte data.
- **`load_file(path: str)`**: Loads the file data to prepare it for encryption.
- **`dump_crp(file_name: str = None, export_dir_path: str = None)`**: Saves the encrypted data to a `.crp` file.
- **`load_crp(path: str)`**: Loads and decrypts a `.crp` file.
- **`dump_file(file_name: str = None, export_dir_path: str = None)`**: Saves the decrypted data to a file.


### CLI Commands

- **`enc`**: Encrypt files in a directory.
- **`dec`**: Decrypt `.crp` files in a directory.


## Contributing 🤝

Feel free to open issues and submit pull requests. Contributions are welcome!

## License 📄

This project is licensed under the MIT License.
odoo-sort-manifest-depends 1.4
Sort modules dependencies section in odoo addon's manifest
Requires Python: >=3.10

# odoo-sort-manifest-depends

## Table of Contents

- [Help](#help)
- [Pre-commit hook](#pre-commit)
- [License](#license)

## Help

```
Usage: odoo-sort-manifest-depends [OPTIONS]

  Sort modules dependencies section in odoo addons manifests and group them by
  type (Third-party, Odoo Community, Odoo Enterprise, Local) and module
  category.

Options:
  --local-addons-dir DIRECTORY  Directory containing manifests to sort
                                [required]
  --odoo-version TEXT           Project's Odoo version (e.g. 16.0)  [required]
  --project-name TEXT           Name of the project, will be the name of
                                category of local addons (default: Local)
  --oca-category                Add category for third party addons coming from OCA
  --reset-cache                 Purge cache used to identify OCA addons
  --help                        Show this message and exit.
```

## Using from the command line

This project is distributed on PyPI. The recommended way to run it is with
[pipx](https://github.com/pypa/pipx), with a command like this:

`pipx run odoo-sort-manifest-depends --local-addons-dir=odoo/addons --odoo-version=16.0`

## Using with pre-commit

This project may be used as a [pre-commit](https://pre-commit.com) hook, with an
entry like this in `.pre-commit-config.yml`.

```yaml
  - repo: https://github.com/acsone/odoo-sort-manifest-depends
    rev: v1.x  # see the release page https://github.com/acsone/odoo-sort-manifest-depends/releases
    hooks:
      - id: odoo-sort-manifest-depends
        args:
          [
            --local-addons-dir=./odoo/addons/,
            --odoo-version=16.0,
            --project-name=MyProject,
          ]
```

## Credits

 * [Laurent Mignon](https://github.com/lmignon)
 * [Thomas Binsfeld](https://github.com/ThomasBinsfeld)
 * [Zina Rasoamanana](https://github.com/AnizR)

## License

`odoo-sort-manifest-depends` is distributed under the terms of the
[MIT](https://spdx.org/licenses/MIT.html) license.