semvec/pypi-packages huggingface dataset:
genai-apis 0.0.10
GenAI APIs provides a unified API callers to Gemini API, OpenAI API, and Anthropic API.
Requires Python: >=3.10
Keywords: genai

# genai-apis

```python
# openai, gemini, gemini-vertex, anthropic, anthropic-vertex, anthropic-bedrock
# !pip install genai-apis[openai]

kwargs = {
  "api_key": "..."
  "GCP_PROJECT_ID": "...",
  "GCP_LOCATION": "...",
  "AWS_LOCATION": "..."
}

extra_kwargs = {
  ...
  stream=False
}

service = "openai"
model = "gpt-4-turbo-2024-04-09"
prompt = "Hello!!"

# openai, 
# gemini, gemini-vertex, 
# anthropic, anthropic-bedrock, anthropic-vertex
api_client = APIFactory.get_api_client(service, **kwargs)
result = await api_client.generate_text(model, prompt, **extra_kwargs)
print(result)

# for stream
async for chunk in result:
    print(chunk, end='')
```
pst-wrinkle 1.4
A small package that wraps selected functions for PST outreach events.
Requires Python: >=3.8

# About the package

**pst_wrinkle** is a Python package designed to showcase selected functions from the Pf7-Public-Notebooks project within a concise public notebook. Please note that this project is currently a work in progress and may be temporary.

## Installation

You can install `pst_wrinkle` using pip:

```bash
!pip install pst-wrinkle
```

## Usage

To import the the package:

```bash
import pst_wrinkle.pst_wrinkle as pst_wrinkle
```

Example of running a function: 

```bash
pst_wrinkle.sample_viewer('PD0129-C', 8, 29000, 30300)
```
kubedantic 0.1.1
Kubedantic - Pydantic models for Kubernetes
Requires Python: >=3.8

Kubedantic
======================================================

.. image:: https://img.shields.io/pypi/v/kubedantic.svg
   :target: https://pypi.org/project/kubedantic

.. image:: https://img.shields.io/pypi/pyversions/kubedantic.svg

.. image:: https://github.com/coherent-oss/kubedantic/actions/workflows/main.yml/badge.svg
   :target: https://github.com/coherent-oss/kubedantic/actions?query=workflow%3A%22tests%22
   :alt: tests

.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json
    :target: https://github.com/astral-sh/ruff
    :alt: Ruff

.. .. image:: https://readthedocs.org/projects/kubedantic/badge/?version=latest
..    :target: https://kubedantic.readthedocs.io/en/latest/?badge=latest

.. image:: https://img.shields.io/badge/skeleton-2024-informational
   :target: https://blog.jaraco.com/skeleton

Kubedantic - Pydantic models for Kubernetes

Overview
--------

Kubedantic is a Python library that provides Pydantic models for Kubernetes resources.

Models are generated using the `Kubernetes OpenAPI specification <https://github.com/kubernetes/kubernetes/tree/master/api/openapi-spec/v3>`_ and `datamodel-code-generator <https://github.com/koxudaxi/datamodel-code-generator>`_.
pruebaJuanCruzCastro 0.6.5
Una biblioteca para consultar cursos de hack4u

# Hack4U Academy Courses Library

Una biblioteca Python para consultar cursos de la academia hack4U.

## Cursos disponibles:

- Introduccion a Linux [15 horas]
- Personalizacion de Linux [3 horas]
- Introduccion al Hacking [53 horas]

## Instalacion

Instala el paquete usando `pip3`:

```python3 
pip3 install hack4u
```

## Uso basico

### Listar todos los cursos

```python
from hack4u import list_courses

for course in list_courses():
    print(course)
```

### Obtener un curso por nombre

```python
from hack4u import get_course_by_name

course = get_course_by_name("Introduccion a Linux")
print(course)
```

### Calcular la duracion total de los cursos

```python3
from hack4u.utils import total_duration
print(f"Duracion total: {total_duration()} horas")
```
epicview 0.2.3
EPIC viewer application.

# EPIC analysis suite viewer tools 

The `epicview` python module (https://github.com/epicsuite/epicview) is a set of tools for viewing 3D genomic data. 

Documentation for this module is available at http://epicsuite.readthedocs.io

## Installing and running the epicview module

Installing the module
```
python3.9 -m venv .venv
source ./.venv/bin/activate
pip install --upgrade pip
pip install epicview 
```

Running a basic test
```
epicview --example
```

Running the application on a session file, as defined in the documentation:
```
epicview session.yaml
```
dyno-dino 1.0.8
Set of useful methods to speed up conversion of objects to AWS services
Requires Python: >=3.6

# DynoDino

DynoDino is a set of useful methods to speed up the conversion of objects to AWS services, specifically DynamoDB. This library allows you to easily convert JSON data to DynamoDB format and vice versa.

## Installation

To install the library, use pip:

```bash
pip install dyno-dino
``` 

## Features

### JSON to DynamoDB Conversion

The library provides methods to convert JSON data structures to the format accepted by DynamoDB. This includes converting common data types like strings, numbers, lists, and nested dictionaries.

Example Usage:

```python
from dyno_dino import convert_json_to_dynamodb

json_data = {
    "name": "Victor",
    "phone": "5587975648710",
    "age": 30,
    "is_verified": True,
    "account_balance": 1234.56,
    "nested_object": {
        "key1": "value1",
        "key2": 2
    },
    "list_data": ["item1", "item2", "item3"]
}

dynamodb_data = convert_json_to_dynamodb(json_data)
print(dynamodb_data)
```

### DynamoDB to JSON Conversion

You can also convert data from DynamoDB format back to JSON, making it easier to manipulate and visualize the data.

Example Usage:
```python
from dyno_dino import convert_dynamodb_to_json

dynamodb_data = {
    "M": {
        "name": {"S": "Victor"},
        "phone": {"S": "5587975648710"},
        "age": {"N": "30"},
        "is_verified": {"BOOL": True},
        "account_balance": {"N": "1234.56"},
        "nested_object": {
            "M": {
                "key1": {"S": "value1"},
                "key2": {"N": "2"}
            }
        },
        "list_data": {"L": [
            {"S": "item1"},
            {"S": "item2"},
            {"S": "item3"}
        ]}
    }
}

json_data = convert_dynamodb_to_json(dynamodb_data)
print(json_data)
```

## Available Methods

`convert_json_to_dynamodb(data: dict) -> dict`

> Converts a JSON dictionary to DynamoDB format.
> * Parameters:
>     * `data` (dict): JSON dictionary to be converted.
> * Returns:
>     * Dictionary in DynamoDB format.


`convert_dynamodb_to_json(dynamodb_data: dict) -> dict`

> Converts a DynamoDB format dictionary to JSON.
> * Parameters:
>     * `dynamodb_data` (dict): DynamoDB format dictionary to be converted.
>     * `remove_content` (bool, optional): Whether to remove the "content" key if it exists. Default is `False`
> * Returns:
>     * JSON dictionary.


## Contributing

Contributions are welcome! Feel free to open issues or pull requests on the [GitHub repository](https://github.com/JoaoGodoi/dyno-dino).
kokojson 0.1.5
A module for safe JSON handling in Python
Requires Python: >=3.6

## A module for safe JSON handling in Python

### Example Usage:
data.json:
```json
{
  "person": {
    "name": "John Doe",
    "age": 30,
    "city": "New York"
  },
  "company": {
    "name": "Acme Inc.",
    "employees": 500
  }
}
```
```python
import kokojson as json1

# Load the JSON data from the file
with open("data.json", "r") as file:
    data = file.read()

# Parse the JSON data using kokojson
json_data = json1.load(data)

# Access existing keys
print(json_data.get("person").get("name"))  # Output: John Doe
print(json_data.get("company").get("employees"))  # Output: 500

# Access non-existing keys (returns None instead of raising an exception)
print(json_data.get("person").get("email"))  # Output: None
print(json_data.get("company").get("website"))  # Output: None

# Provide a default value for non-existing keys
print(json_data.get("person").get("email", "No email found"))  # Output: No email found
print(json_data.get("company").get("website", "https://example.com"))  # Output: https://example.com
```
bezzanlabs.gpt-docgen 0.1.0
CLI tool to generate project documentation from GPT models.
Requires Python: ==3.11

# `gpt_docgen`

## Introduction

Welcome to the `gpt_docgen` repository, a cutting-edge documentation generation tool designed to streamline the process of creating detailed, accurate, and insightful documentation for your codebase using the power of language models. 

The primary features of `gpt_docgen` include:

- **Automatic Markdown Generation**: Automatically generates markdown files that describe the functionalities and usage of your code files, making your documentation process as effortless as possible.
- **Custom Model Support**: With support for multiple language models, you can choose the model that best fits your needs and preferences for documentation style and detail level.
- **CLI Integration**: Easy-to-use command-line interface that simplifies the process of generating documentation for any project, regardless of size or complexity.

## Installation

To install `gpt_docgen`, you will need Python 3.11 or newer. Follow these steps to get started:

1. Clone the repository to your local machine:
   ```bash
   git clone https://github.com/vitorbezzan/gpt_docgen.git
   ```
2. Navigate to the cloned directory:
   ```bash
   cd gpt-docgen
   ```
3. Install the package in a virtual environment (Python 3.11) using pip:
   ```bash
   pip install .
   ```

You can also install the package directly from PyPI using pip:
    
```bash
pip install bezzanlabs.gpt_docgen
```

This package is made to be run inside its own virtual environment, so it is recommended to create one before running the package.

## Example

To generate documentation for your codebase, navigate to your project directory and run:

```bash
gpt_docgen describe_file --path /path/to/your/file.py
```

You can specify the model and vendor you wish to use with additional flags. For a detailed explanation of all available commands and options, use:

```bash
gpt_docgen --help
```

This will provide you with a help disclaimer.



*This documentation was generated using gpt-4-turbo-preview.*