semvec/pypi-packages huggingface dataset:
jpaulorc-csv-converter 0.1.3
Convert csv to json and json to csv. Publishin only for leaning purposes.
Requires Python: >=3.9,<4.0

# File Converter

Used to convert files to CSV or JSON.
This project does not use any library to convert these files.

## Introduction

Learning how to deploy a lib on PyPi at PUC using Poetry.



### What this project can do

Read a **CSV** or **JSON** file or a **folder** with files and convert them to **CSV** or **JSON**.

 - If the file was a **CSV** then it will be converted to **JSON**.
 - If the file was a **JSON** then it will be converted to **CSV**.

This project is a program running on terminal, preferably install with pipx:


```bash
pipx install jpaulorc-csv-converter
```

To use, just type in:

```bash
csv_converter --help
```

This will list all available options.
carvajal 0.2.1
Helper functions for describing AWS infrastructure
Requires Python: >=3.6

carvajal
========

Helper functions for describing AWS infrastructure.

``carvajal`` is particularly intended for writing tests,
but can also be used for monitoring and auditing.

``carvajal`` includes terraform helpers to look up 
variables, data sources, and other terraform objects.

``carvajal`` has been in use for a few years now,
but you should not consider it stable (yet).
Pin your version in your ``requirements.txt``,
please, or be prepared to rewrite some of your tests on occasion.
``carvajal`` will always follow semantic versioning.

Complete documentation is at
https://carvajal.readthedocs.io/en/latest/index.html.

Source code is at
https://github.com/coalfire/carvajal.

usage
~~~~~

``pip install carvajal``

Create a ``test`` directory.

Write some tests for all of your instances in ``test/test_all.py``:

.. code-block:: python

    import pytest

    from carvajal import aws

    def test_none_accept_ssh_from_world():
        my_instances = aws.get_instances()
        ssh_ingress_rules = aws.instances_ingress_rules_for_port(my_instances, 22)
        actual = aws.rules_cidrs_and_security_groups(ssh_ingress_rules)
        assert "0.0.0.0/0" not in actual["cidrs"]


Run ``pytest``.


philosophy and alternatives
---------------------------

``carvajal`` has some guiding principals:

* test deployed resources, not the deploy code.
* make broad assertions about the state of your infrastructure - for instance:

   * nothing has 22 open from the world.
   * web instances only allow 443 in.

* test in production.

   * It's not that we are *not* going to test before we go to prod.
   * It is that we are going to *continue* testing once we reach prod.

* use an existing language (in this case Python),
  rather than having new tools specific to Infrastructure-as-Code.

   * At least some users will not have to learn a new language
   * Users can choose from multiple test frameworks (pyunit, pytest, etc)
   * Users can integrate into other tools - for instance, prometheus exporters.

* ``carvajal`` is only one of many tools for testing Infrastructure-as-Code.
* we don't think other Infrastructure-as-Code philosphies are wrong,
  but they do not accomplish what ``carvajal`` is trying to accomplish.


Some other tools you might consider are:

* `Terratest <https://terratest.gruntwork.io/>`_

* `Kitchen-Terraform <https://github.com/newcontext-oss/kitchen-terraform>`_

* `InSpec <https://community.chef.io/tools/chef-inspec>`_

* `Serverspec <https://serverspec.org/>`_

* `ScoutSuite <https://github.com/nccgroup/ScoutSuite>`_

development
------------

.. code-block:: shell

    make help

to do
-----

We need tests.

We need type hints.

Function names could do with a thorough review and setting a standard format.
dataclass-argparse 0.1.2
argparse with a type annotated namespace dataclass

# dataclass-argparse
Define command line arguments as type annotated namespace dataclasses.

Advantages:
 - fast, straight forward definition of command line arguments
 - use inheritance to combine argument groups 
 - use inheritance to define sub-parsers
 - keep your parsed args in one joined (or several separate) namespace dataclass instances 

# Example 1: group arguments with inheritance; parse jointly
```python
from dataclasses import dataclass, field
from typing import Tuple

from dataclass_argparse import NonEmptyList, TypedNamespace


@dataclass
class ArgsA(TypedNamespace):
    a1: int = 1
    a2: NonEmptyList[int] = field(default_factory=lambda: [1], metadata={"help": "help for a2."})


@dataclass
class ArgsB(TypedNamespace):
    b1: str = field(metadata={"metavar": "REQ_B1"})
    b2: bool = False
    b3: Tuple[int, int] = field(default=(1, 2), metadata=dict(help="help for b3."))


@dataclass
class Args(ArgsA, ArgsB):
    pass


def func_a(args: ArgsA):
    print("func a", args.a1, args.a2)


def func_b(args: ArgsB):
    print("func b", args.b1, args.b2, args.b3)


def func_c(args: Args):
    print("func a", args.a1, args.a2)
    print("func b", args.b1, args.b2, args.b3)


parser = Args.get_parser_grouped_by_parents()

if __name__ == "__main__":
    parsed_args = parser.parse_args()

    parser.print_help()

    func_a(parsed_args)
    func_b(parsed_args)
    func_c(parsed_args)

```

# Example 2: group arguments with argparse; parse groups separately
```python
import argparse
from dataclasses import dataclass, field
from typing import ClassVar

from dataclass_argparse import NonEmptyList, TypedNamespace


@dataclass
class ArgsA(TypedNamespace):
    a1: ClassVar[int] = 1
    a2: NonEmptyList[int] = field(default_factory=lambda: [1], metadata={"help": "help for a2."})


parser_a = ArgsA.get_parser("group A")


def func_a(args: ArgsA):
    print("func a", args.a1, args.a2)


@dataclass
class ArgsB(TypedNamespace):
    b1: str = field(metadata={"metavar": "REQ_B1"})
    b2: bool = False


parser_b = ArgsB.get_parser("group B")


def func_b(args: ArgsB):
    print("func b", args.b1, args.b2)


# join created parsers with argparse
joint_parser = argparse.ArgumentParser(parents=[parser_a, parser_b], add_help=False)
# arguments used directly (not part of a typed namespace groups)
general_args = joint_parser.add_argument_group("General")
general_args.add_argument("-h", "--help", action="help", help="show this help message and exit")


if __name__ == "__main__":
    joint_parser.parse_args()  # show help/complain about missing/unknown args, but ignore parse args

    # parse args
    args_a, unused_args = parser_a.parse_known_args()
    args_b, unused_args = parser_b.parse_known_args(unused_args)

    joint_parser.print_help()

    func_a(args_a)
    func_b(args_b)

```
freeclimb 3.0.2
FreeClimb API
Keywords: OpenAPI,OpenAPI-Generator,FreeClimb API

    FreeClimb is a cloud-based application programming interface (API) that puts the power of the Vail platform in your hands. FreeClimb simplifies the process of creating applications that can use a full range of telephony features without requiring specialized or on-site telephony equipment. Using the FreeClimb REST API to write applications is easy! You have the option to use the language of your choice or hit the API directly. Your application can execute a command by issuing a RESTful request to the FreeClimb API. The base URL to send HTTP requests to the FreeClimb REST API is: /apiserver. FreeClimb authenticates and processes your request.  # noqa: E501
and-eggs 0.0.7
GMail Bot API
Requires Python: >=3.6


# AndEggs

AndEggs is a Python library that allows you to create an email bot using Gmail's API.

# Simple Documentation

## Client Class

The `Client` class will be the main entry point of your program. 

### Create a Client

First, create a new client by calling the `Client` constructor:

```python
    >>> from andeggs import Client
    >>> client = Client('CommandPrefix')
```

Then, you can use the `Client` object to interact with Gmail's API.

### Creating a Command

To create a command, you should create an asynchronous function that will be called when the command is triggered.
It should take in a `MailContext` object as its only parameter. This object contains all the information about the email that triggered the command.
To turn it into a command, use the `Client.command` decorator:

```python
    >>> @client.command('CommandName')
    >>> async def command(context: MailContext):
    >>>     # Do something
    >>>     pass
```

### Sending an Email

To send an email, you should use the `Client.send` method:

```python
    >>> client.send(
    >>>     to='RecipientEmail',
    >>>     subject='Subject',
    >>>     body='Body',
    >>>     is_html=False,
    >>> )
```

### Activating the Client

To activate the client, you should call the `Client.run` method:

```python
    >>> client.run('youremail', 'yourpassword')
```

### Events

Events are triggered when certain actions happen. Below is a list of the events that can be triggered and their parameters:

* `on_ready`: Triggered when the client is started.
* `on_message`: Triggered when a new email is received. The parameter is a `MailContext` object.
* `on_send`: Triggered when an email is sent. The parameter is a `MailContext` object.
* `on_command`: Triggered when a command is triggered. The parameter is a `MailContext` object.
* `on_stop`: Triggered when the client is stopped.

### Tasks

A task is a function that runs in the background. You can use the `Client.task` decorator to create a task:

```python
    >>> @client.task(interval=60)
    >>> async def task():
    >>>     # Do something
    >>>     pass
```

## MailContext

On all of your commands, you will receive a `MailContext` object. This object contains all the information about the email that triggered the command.

### Attributes
- `sender`: A `Sender` object.
- `subject`: The subject of the email.
- `body`: The body of the email.

### Sending an Email

You can also send an email using the `MailContext.send` method:

```python
    >>> context.send(
    >>>     'Body',
    >>> )
```

If you want to format your text with html, you should use the `MailContext.sendf` method:

```python
    >>> context.sendf(
    >>>     '<p>{}</p>',
    >>>     'Body',
    >>> )
```