semvec/pypi-packages huggingface dataset:
paddl 0.3.0
Parse Any DDL
License: MIT

# paddl: Parse Any DDL

Parse DDLs into objects using python. 

Ambitious title, supported SQL languages include:

- Rudamentary `CREATE TABLE` implemented, pursuing MySQL 8 first.


```python
from paddl import parse, ColType

schema = parse("CREATE TABLE employees (id int, name varchar(255));", 'mysql')
table = schema.tables[0]

table.name 
# "employees"

table.columns

column = table.columns[0]
column.name == 'id'
column.type == ColType.INT
```

## command line

`paddl` offers "No Code" CLI solutions, such as rendering ER Diagrams.

```sh
> python -m paddl
usage: paddl [-h] [--erd] sql
```
tinypipeline 0.3.0
A tiny mlops library for building machine learning pipelines on your local machine.
License: MIT
Requires Python: >=3.9
Keywords: mlops,machine learning,pipelines

# tinypipeline

## Overview

`tinypipeline` is a tiny mlops library that provides a simple framework for organizing your machine learning pipeline code into a series of steps. It does not handle networking, I/O, or compute resources. You do the rest in your pipeline steps.

## Installation

```
$ pip install tinypipeline
```

## Usage

`tinypipeline` exposes two main objects:
- `pipeline`: a decorator for defining your pipeline. Returns a `Pipeline` instance.
- `step`: a decorator that is used to define individual pipeline steps. Returns a `Step` instance.

Each object requires you provide a `name`, `version`, and `description` to explicitly define what pipeline you're creating.

The `Pipeline` object that is returned from the decorator has a single method: `run()`.

## API

If you'd like to use this package, you can follow the `example.py` below:

```python
from tinypipeline import pipeline, step

# define all of the steps
@step(name='step_one', version='0.0.1', description='first step')
def step_one():
    print("Step function one")

@step(name='step_two', version='0.0.1', description='second step')
def step_two():
    print("Step function two")

@step(name='step_three', version='0.0.1', description='third step')
def step_three():
    print("Step function three")

@step(name='step_four', version='0.0.1', description='fourth step')
def step_four():
    print("Step function four")


# define the pipeline
@pipeline(
    name='test-pipeline', 
    version='0.0.1', 
    description='a test tinypipeline',
)
def pipe():
    # run the steps in the defined order
    return [
        step_one, 
        step_two, 
        step_three, 
        step_four,
    ]

pipe = pipe()
pipe.run()
```

You can also define steps using a dictionary, where each key of the dictionary
is a step to run, and the values are steps that run after the step named in the key.

```python
# define the pipeline
@pipeline(
    name='test-pipeline', 
    version='0.0.1', 
    description='a test tinypipeline',
)
def pipe():
    # run the steps in the defined order of the graph
    return {
        step_one: [step_two, step_four],
        step_two: [step_three, step_four]
    }
```


**Output**:

You can run the `example.py` like so:

```console
$ python example.py
+-------------------------------------------------------------------+
| Running pipeline: Pipeline(name='test-pipeline', version='0.0.1') |
+-------------------------------------------------------------------+

Running step [step_one]...
Step function one
Step [step_one] completed in 0.000325 seconds

Running step [step_two]...
Step function two
Step [step_two] completed in 0.000286 seconds

Running step [step_three]...
Step function three
Step [step_three] completed in 0.000251 seconds

Running step [step_four]...
Step function four
Step [step_four] completed in 0.000313 seconds
```

## Running tests

Tests are run using pytest. To run the tests you can do:

```console
$ pip install pytest
$ pytest
```
chatcli 0.1.20
Streaming CLI interface for OpenAI's Chat API
License: MIT
Requires Python: >=3.10,<4.0

# ChatCLI

ChatCLI is a command line interface for OpenAI's Chat API.

 ChatCLI aims to provide a similar experience the ChatGPT frontend; like ChatGPT, ChatCLI streams tokens from the model as they are generated.

```console
$ chatcli
ChatCLI v0.1.5 | [↩] to submit | [ALT/⌥] + [↩] for newline
>>> Write 3 funny prompts for yourself.
1. If you could only communicate through interpretive dance for the next 24 hours, how would you go about your day?

2. You wake up in a world where everyone speaks in rhyme. How do you adapt to this unusual circumstance?

3. You can only speak in questions for the rest of the day. How do you navigate conversations with friends, co-workers, and strangers?
```

## Installation

To install ChatCLI, use pip:

```
pip install chatcli
```

You'll need an OpenAI API key to use ChatCLI. You can get one [here](https://beta.openai.com/).

ChatCLI reads your key from the `OPENAI_API_KEY` environment variable, so you'll also need to set that.

## Usage

### CLI Usage

To use ChatCLI, simply run the `chatcli` command:

```
chatcli
```

This will start a chat session with the default OpenAI model. You can type your messages and the AI will respond.

You can exit the chat at any time by typing "exit" into the prompt or pressing Ctrl+C.

### Python Usage

ChatCLI can also be used as a Python library. Here's an example:

```python
import chatcli
# Create the chat generator
generator = chatcli.ChatGenerator()

# Send a message to the generator
response = generator.send("Prove Riemann's Hypothesis.")

# Print the response
print(response["message"]["content"])
```

This will send a message to the API and then print the response stream as it is generated.

## License

ChatCLI is licensed under the MIT license. See [LICENSE](LICENSE) for details.