semvec/pypi-packages huggingface dataset:
fast-trie-set 0.6.1
A fast and efficient trie-based collection for storing and searching millions of strings.
License: MIT
Requires Python: >=3.6

# TRIE Module

A fast and efficient trie-based set for storing and searching millions of short strings.

## Features

- Add strings to the set quickly.
- Search for strings in constant time complexity.
- Iterate through stored strings in lexicographical order.
- Support for prefix matching.
- Case-insensitive search.
- Export and import trie data to/from JSON.
- Supports word deletion.

## Installation

```bash
pip install fast_trie_set
```

## Usage

```python
from fast_trie import TRIE

# Initialize the Trie with a list of words
trie = TRIE(['hello', 'world', '!', ',', 'hen', 'hell'], case_insensitive=True)

# Add a word
trie.add('Help')

# Extend trie with a list of words
trie.extend(['HeLLo', 'WoRlD'])

# Check if a word exists
print('hello' in trie)  # True
print('unknown' not in trie)  # True

# Find index of a word
print(trie.find('hell'))  # Index of 'hell'

# Match words with a given prefix
print(list(trie.prefix_match('he')))  # ['hello', 'hen', 'hell', 'help']

# Delete a word
trie.delete('hell')
print(list(trie))  # ['hello', 'world', '!', ',', 'hen', 'help']

# Export the trie to a JSON file
trie.export("trie.json")

# Import a trie from a JSON file
imported_trie = TRIE.import_trie("trie.json", case_insensitive=True)
print(list(imported_trie))  # ['hello', 'world', '!', ',', 'hen', 'help']
```

## License

MIT License. See LICENSE file for more details.
cenclave-lib-sgx 1.1.1
Library to bootstrap WSGI/ASGI application for Gramine
License: MIT
Requires Python: >=3.10

# Cosmian Enclave Lib SGX

## Overview

Cosmian Enclave lib SGX bootstraps the execution of an encrypted ASGI/WSGI Python web application for [Gramine](https://gramine.readthedocs.io/).

The library is responsible for:

- Configuring the SSL certificates with either:
  - *RA-TLS*, a self-signed certificate including the Intel SGX quote in an X.509 v3 extension
  - *Custom*, the private key and full keychain is provided by the application owner
  - *No SSL*, the secure channel may be managed elsewhere by an SSL proxy
- Decrypting Python modules encrypted with XSala20-Poly1305 AE
- Running the ASGI/WSGI Python web application with [hypercorn](https://pgjones.gitlab.io/hypercorn/)

## Technical details

The flow to run an encrypted Python web application is the following:

1. A first self-signed HTTPS server using RA-TLS is launched waiting to receive a JSON payload with:
   - UUID, a unique application identifier provided to `cenclave-bootstrap` as an argument
   - the decryption key of the code
   - Optionally the private key corresponding to the certificate provided to `cenclave-bootstrap` (for *Custom* certificate)
2. If the UUID and decryption key are the expected one, the configuration server is stopped, the code is decrypted and finally run as a new server


## Installation 

```console
$ pip install cenclave-lib-sgx
```

## Usage

```console
$ cenclave-bootstrap --help
usage: cenclave-bootstrap [-h] [--host HOST] [--client-certificate CLIENT_CERTIFICATE] [--port PORT]
                          [--subject SUBJECT] [--san SAN] --app-dir APP_DIR --id ID [--timeout TIMEOUT]
                          [--version] [--debug]
                          (--ratls EXPIRATION_DATE | --no-ssl | --certificate CERTIFICATE_PATH)
                          application

Bootstrap ASGI/WSGI Python web application for Gramine

positional arguments:
  application           ASGI application path (as module:app)

options:
  -h, --help            show this help message and exit
  --host HOST           hostname of the server
  --client-certificate CLIENT_CERTIFICATE
                        For client certificate authentication (PEM encoded)
  --port PORT           port of the server
  --subject SUBJECT     Subject as RFC 4514 string for the RA-TLS certificate
  --san SAN             Subject Alternative Name in the RA-TLS certificate
  --app-dir APP_DIR     path of the python web application
  --id ID               identifier of the application as UUID in RFC 4122
  --timeout TIMEOUT     seconds before closing the configuration server
  --version             show program's version number and exit
  --debug               debug mode with more logging
  --ratls EXPIRATION_DATE
                        generate a self-signed certificate for RA-TLS with a specific expiration date (Unix time)
  --no-ssl              use HTTP without SSL
  --certificate CERTIFICATE_PATH
                        custom certificate used for the SSL connection, private key must be sent through the
                        configuration server
```
binaryconvert 3.0.0
A Python tool that converts text to binary and other formats like hexadecimal, Base64, Morse code, and more!
License: MIT
Requires Python: >=3.6
Keywords: binary, binaries, text-to-binary, hexadecimal, base64, morse-code, utilities, converter


# BinaryConvert CLI Library

This library provides a Command-Line Interface (CLI) for converting text between various encoding formats, including binary, hexadecimal, decimal, Base64, Morse code, leetspeak, and more.

## Available Commands

### `to_binary <text> <bit>`
Convert text to its binary representation.

Example:
```bash
$ python cli.py to_binary "Hello World" 8
```

### `to_text <binary>`
Convert binary to text.

Example:
```bash
$ python cli.py to_text "01001000 01100101 01101100 01101100 01101111 00100000 01010111 01101111 01110010 01101100 01100100"
```

### `to_hex <text>`
Convert text to hexadecimal representation.

Example:
```bash
$ python cli.py to_hex "Hello World"
```

### `from_hex <hex_string>`
Convert hexadecimal string to text.

Example:
```bash
$ python cli.py from_hex "48 65 6c 6c 6f 20 57 6f 72 6c 64"
```

### `to_decimal <text>`
Convert text to decimal representation.

Example:
```bash
$ python cli.py to_decimal "Hello World"
```

### `from_decimal <decimal_string>`
Convert decimal string to text.

Example:
```bash
$ python cli.py from_decimal "72 101 108 108 111 32 87 111 114 108 100"
```

### `reverse_text <text>`
Reverse the input text.

Example:
```bash
$ python cli.py reverse_text "Hello World"
```

### `to_base64 <text>`
Encode text to Base64.

Example:
```bash
$ python cli.py to_base64 "Hello World"
```

### `from_base64 <base64_string>`
Decode Base64 string to text.

Example:
```bash
$ python cli.py from_base64 "SGVsbG8gV29ybGQ="
```

### `is_palindrome <text>`
Check if the text is a palindrome.

Example:
```bash
$ python cli.py is_palindrome "A man a plan a canal Panama"
```

### `count_characters <text>`
Count the frequency of each character in the text.

Example:
```bash
$ python cli.py count_characters "Hello World"
```

### `to_leetspeak <text>`
Convert text to leetspeak.

Example:
```bash
$ python cli.py to_leetspeak "Hello World"
```

### `to_morsecode <text>`
Convert text to Morse code.

Example:
```bash
$ python cli.py to_morsecode "Hello World"
```

### `from_morsecode <morse_code>`
Convert Morse code to text.

Example:
```bash
$ python cli.py from_morsecode ".... . .-.. .-.. --- / .-- --- .-. .-.. -.."
```

## Requirements

- Python 3.x
- `click` library (install using `pip install click`)

## Installation

1. Clone or download the repository.
2. Install the required dependencies:
   ```bash
   pip install -r requirements.txt
   ```
3. Run the CLI using:
   ```bash
   python cli.py <command> <args>
   ```

## License

This project is licensed under the MIT License - see the LICENSE file for details.