semvec/pypi-packages huggingface dataset:
envify 1.0.0
A friendly enviroment variable parser to describe envs and parse them. This will make documenting environment variables easier.
Requires Python: <4.0,>=3.10

# Env Parser

A friendly enviroment variable parser to describe envs and parse them. This will make documenting environment variables easier.

## Basic Usage

Import the `config` function and provide a configuration `.yaml` or `.yml` file to it as bellow:

```yaml
envs:
    env_id:
        name: string
        description: string
        options: [value_type]
        required: true | false
        value_type: str | int | bool | float
```

example:

```yaml
envs:
  redis_url:
    name: 'REDIS_URL'
    description: "The redis database URL"
    options: ['redis://localhost:6379']
    required: true
    value_type: str
```

The `config` function returns a `dict` with the parsed envs converted to it's type.

### Env Properties

- `name`: it should be the same string as in your .env file
- `description`: a short description of what is it
- `options`: a list of the possible values the env can receive
    - If any different value is provided, it will issue an error
- `required`: if the env variable is required or not
- `value_type`: a string representing the convertion type of the env value
    - Currently supports: `str`, `int`, `bool` and `float`

## Multiple Environs

To use multiple environs, must set the `multi` key to `true` and you have to add them as top level after the `envs:` directive. We have three possible environs: `development`, `staging`, `production`.

```yaml
envs:
    multi: true
    active: 'development' | 'staging' | 'production' 
    development:
        # Normal env declaration
    staging:
        # Normal env declaration
    production:
        # Normal env declaration
```

In your `.env` (or wherever you put your envs), for each type of environ, the env must have the correct prefix:

- `DEV_` for `development`
- `STAG_` for `staging`
- `PROD_` for `production`

The loader will return a tuple: `(active, envs)` with the active environ and all of the parsed environs, respectively.

If no `active` is provided, it will return `(None, envs)`.

If you enable environs, you can't have misplaced envs outside of them to avoid possible security issues.

### Possible Errors

- If an environment is empty, it will issue a waring
- If a name different than the reserved ones for a eviron is giver, it will issue an error
    - _Custom environs are in progress!_
- If your not using environments and make use of the `active: true|false` directive, it will treat it as a env variable and issue a invalid env error
HoloforgeAI-CLI 0.1.0
A CLI companion tool for managing Holoforge applications
Requires Python: >=3.6

## Holoforge CLI

This is the command-line interface (CLI) for Holoforge, a tool that helps you manage and deploy serverless applications on AWS.

### Getting Started

**Prerequisites:**

- Python 3.6 or later
- AWS CLI configured with proper credentials
- `sam` CLI installed (`pip install aws-samcli`)

**Installation:**

There is no separate installation for the Holoforge CLI. It seems to be part of a larger codebase.

### Usage

The CLI supports two main commands:

- `init`: Initializes a new SAM project with basic configuration.
- `pull`: Pulls code for an existing application from a remote location (likely AWS API Gateway) and configures the local SAM project.

**`init` command:**

```
holo init <project-name>
```

This command creates a new SAM project named `<project-name>` with a basic structure and configuration for a Python 3.12 application.

**`pull` command:**

```
holo pull <app-id>
```

This command pulls the code for an application with the ID `<app-id>` from a remote location and configures the local SAM project. It performs the following steps:

1. Authenticates with AWS Cognito using the credentials stored in a configuration file (~/.hfcredentials).
2. Retrieves the application details from the API Gateway using the provided `<app-id>`.
3. Extracts the YAML template and Lambda function code from the response.
4. Saves the YAML template to a file named `template.yaml` in the current working directory.
5. Creates directories for each Lambda function and saves the function code to the corresponding `.py` file in the respective directory.
6. (Optional) Saves any requirements specified for the Lambda functions to a `requirements.txt` file in the corresponding function directory.

**Storing Credentials:**

The CLI stores your AWS credentials in a configuration file named `.hfcredentials` in your home directory. If the file doesn't exist, the first time you run `holo pull`, you will be prompted to enter your username and password.

**Clear Screen Animation (Optional):**

The code includes functionality for displaying an animation during some operations (commented out). You can uncomment the relevant sections if you want to enable the animations.

### Caveats and Limitations

- The code assumes a specific structure for the response received from the API Gateway.
- Error handling is limited.
- The `pull` command logic for retrieving and processing application code needs to be implemented based on the actual logic used by Holoforge.

### Contributing

If you want to contribute to Holoforge, refer to the project's contribution guidelines (if available).
zcached.py 1.2.1
A lightweight client-side library for zcached, written in Python.
Requires Python: >=3.8

# Zcached.py - A client-side library for zcached.

![commits](https://img.shields.io/github/commit-activity/w/xXenvy/zcached.py?style=for-the-badge&color=%2315b328)
![license](https://img.shields.io/github/license/xXenvy/zcached.py?style=for-the-badge&color=%2315b328)
![release](https://img.shields.io/github/v/release/xXenvy/zcached.py?include_prereleases&style=for-the-badge&color=%2315b328)

## `📜` Introduction
Zcached.py is a Python client-side library designed to interact with zcached, a high-performance in-memory caching system.
This library provides developers an easy-to-use interface for integrating zcached into their Python applications, enabling efficient data caching.

For more information, please see [zcached repository](https://github.com/sectasy0/zcached).

## `🌟` Features
- **Simplified Caching:** Zcached.py simplifies the process of caching data by providing intuitive functions for storing and retrieving values.
- **Efficient Communication:** The library optimizes communication with the zcached server, ensuring minimal overhead and efficient data transfer.
- **Properly Typehinted:** The codebase of zcached.py is properly typehinted, enhancing code readability.

## `🔧` Installation
> [!IMPORTANT]  
> **Library requires python version 3.8 or newer.** (Older also should work, but untested).

Before installing zcached.py, ensure that you have the zcached server. Instructions for installing and running the server can be found [here](https://github.com/sectasy0/zcached).

Once the zcached server is ready to use, you can proceed to install zcached.py using pip:
```shell
pip install -U zcached.py
```

## `🖊️` Usage
Here's a basic example demonstrating how to use zcached.py in your Python code:
```py
from typing import List
from zcached import ZCached, Result

client = ZCached(host="localhost", port=5555)
client.run()

if client.is_alive() is False:
  raise RuntimeError("Something went wrong.")

client.set(key="dogs", value=["Pimpek", "Laika"])

dogs_result: Result[List[str]] = client.get(key="dogs")
dbsize_result: Result[int] = client.dbsize()
keys_result: Result[List[str]] = client.keys()
print(keys_result.value)

client.save()
client.delete("dogs")
client.flush()
```
**See more examples [here](https://github.com/xXenvy/zcached.py/tree/master/examples)**

## `👥` Contributing
Contributions to zcached.py are welcome!
If you encounter any issues or have suggestions for improvements, please feel free to open an issue or submit a pull request.

## `📕` License
Zcached.py is licensed under the MIT License.