semvec/pypi-packages huggingface dataset:
TurboCLI 0.2.2
A simple Python package for CLI tools
Requires Python: >=3.7

[![Tests](https://github.com/TheDoubleMix/TurboCLI/actions/workflows/python-tests.yml/badge.svg)](https://github.com/TheDoubleMix/TurboCLI/actions)
[![Python versions](https://img.shields.io/pypi/pyversions/TurboCLI)](https://pypi.org/project/TurboCLI/)
[![Pypi Package](https://img.shields.io/pypi/v/TurboCLI)](https://pypi.org/project/TurboCLI/)

# TurboCLI

A simple Python package for displaying CLI Tools.

## Features:
- Show data as a hex editor.

## Example Usage:

```python
from turbocli import hexdump

# Example byte sequence (DEADBEEF)
data = b'\xde\xad\xbe\xef'

# Display the hex dump
print(hexdump(data))
```
### Expected Output:
```
00000000  DE AD BE EF                                      ....
```
This will print out a hex dump where each line contains the offset (starting at `00000000`), the hexadecimal representation of the bytes, and their corresponding ASCII characters (non-printable characters are displayed as a dot).

## Lisence:
This project uses the MIT License.
##
Thank you for using the CLI Python module! 🎉
oxhttp 0.2.9
OxHttp is http server for python build in rust
Requires Python: >=3.8

# OxHTTP

_OxHTTP_ is Python HTTP server library build in Rust - a fast, safe and feature-rich HTTP server implementation.

## Features

- Routing with path parameters
- Middleware support
- Static file serving
- Application state management
- Request/Response handling
- Query string parsing

## Basic Example

```python
from oxhttp import HttpServer, get, Router, Status, Response


@get("/")
def welcome():
    return Response(Status.OK, "Welcome to OxHTTP!")

@get("/hello/{name}")
def hello(name):
    return Response(Status.OK, {"message": f"Hello, {name}!"})

router = Router()
router.routes([welcome, hello])

app = HttpServer(("127.0.0.1", 5555))
app.attach(router)

if __name__ == "__main__":
    app.run()
```

## Middleware Example

```python
def auth_middleware(request, next, **kwargs):
    if "Authorization" not in request.headers:
        return Status.UNAUTHORIZED
    return next(**kwargs)

@get("/protected")
def protected():
    return "This is protected!"

router = Router()
router.middleware(auth_middleware)
router.route(protected)
```

## Static Files

```python
router = Router()
router.route(static_file("./static", "static"))
# Serves files from ./static directory at /static URL path
```

## Application State

```python
class AppState:
    def __init__(self):
        self.counter = 0

app = HttpServer(("127.0.0.1", 5555))
app.app_data(AppState)

@get("/count")
def handler(app_data):
    app_data.counter += 1
    return {"count": app_data.counter}


router = Router()
router.route(handler)
```

Todo:

- [x] Handler
- [x] HttpResponse
- [x] Routing
- [x] use tokio::net::Listener
- [x] middleware
- [x] app data
- [x] pass request in handler
- [x] serve static file
- [ ] templating
- [x] query uri
- [ ] security submodule (jwt,bcrypt..)
- [ ] websocket
bolt-ta 0.4.1
A simple task runner written in Python
Requires Python: >=3.8

# Bolt Task Automation

[![Verify Python Library](https://github.com/abantos/bolt/actions/workflows/python-verify-library.yml/badge.svg)](https://github.com/abantos/bolt/actions/workflows/python-verify-library.yml)

Bolt is a task runner inspired by [grunt](http://gruntjs.com/) and written in
[python](http://www.python.org) that helps you automate any task in your project
whether it is executed in your development environment or in your CI/CD pipeline.
Bolt gives you the power to specify how tasks should be executed, and it takes
care of the rest. And it is as simple as describing and configuring your tasks
in the `boltfile.py`.

```python
# boltfile.py

import bolt

config = {
    'pip': {
        'command': 'install',
        'options': {
            'r': './requirements.txt'
        }
    },
    'delete-pyc': {
        'sourcedir': './src',
        'recursive': True
    },
    'nose': {
        'directory': './tests',
        'options': {
            'with-xunit': True,
            'xunit-file': './logs/unit_test_log.xml'
        }
    }
}

bolt.register_task('run-tests', ['pip', 'delete-pyc', 'nose'])
```

```bash
# in your favorite shell

bolt pip
# to install requirements

bolt nose
# executes unit tests

bolt run-tests
# installs requirements, deletes .pyc files, and runs unit tests
```

## Why Use Bolt?

Let's face it, you want to automate everything, but doing so becomes a burden;
especially, if you are working on a cross-platform application. You may find
your-self switching CI/CD systems and going through the pain of
rewriting your pipelines to the specific domain languages they use. Python
is cross-platform and any pipline will allow you to execute a command. This
makes Bolt ideal to create reusable tasks that can execute in any environment
indpendently of tools. And, It's fun!


## How Can I Get Started?

You can start by installing bolt and following the examples in the
[Getting Started](https://bolt-task-automation.readthedocs.io/en/latest/using/getting_started.html)
guide. Once you become familiar with Bolt, you can look at other topics in
[Using Bolt](https://bolt-task-automation.readthedocs.io/en/latest/using_bolt.html),
to learn about the different features it provides.


## This is Great! I want to Help!

Help is highly appreciated! If you want to contribute to the project, make sure
to read our [guidelines](https://bolt-task-automation.readthedocs.io/en/latest/contribute.html).
If you are a tool developer, and you want to provide Bolt support in your
library or application don't hesitate asking for help. We want to build a great
community around Bolt, and we will help you in any way we can.


Make sure you read the [bolt documentation](http://bolt-task-automation.readthedocs.io).