semvec/pypi-packages huggingface dataset:
djambe-Scripts 0.1.0
Scripts for Djambe
Requires Python: >=3.9

Djambe: Python Web Framework for the future.

Welcome to Djambe, a Python web framework that allows you to use JSX expressions in your applications! With Djambe, you can build dynamic web applications using the Model-View-Controller (MVC) architecture and a SQLite database. Installation

To install Djambe, use pip:

pip install djambe

Usage

To use Djambe in your application, you will need to create PyV (Python View) files that contain your JSX expressions. These PyV files will be rendered by the framework and sent to the client as HTML.

Here is a simple example of a PyV file.

<template>
<h2>Hello, {noun}!</h2>
</template>
<script>
  data = {
    "noun": "World"
  }
</script>

To use the MVC architecture with Djambe, you will need to create separate PyV files for your views and controllers. Your controllers will handle the logic of your application and interact with the SQLite database, while your views will contain the JSX expressions that are rendered and sent to the client.

For more information on using Djambe and its MVC architecture, please refer to the documentation:

https://djambe.readthedocs.io/

If you have any questions or need additional help, please don't hesitate to reach out to our support team at support@djambe.com.
aidoc 0.1.5
A simple CLI tool to generate documentation for your Python projects automatically.
Requires Python: >=3.6

[![PyPI](https://badge.fury.io/py/aidoc.svg)](https://pypi.org/project/aidoc/)

# aidoc

aidoc is a command line interface (CLI) tool that uses AI to automatically generate documentation for your code.

## Requirements

- OpenAI API key: [https://beta.openai.com/](https://beta.openai.com/)
- Python 3.6 or higher


## Installation

- globally install the package

```
python3 -m pip install aidoc
```

- (recommended) create a virtual environment and install the package

```bash
pip install aidoc
```

## Usage

To configure the API key and model for aidoc, run the following command:

```
aidoc configure
```

To generate documentation for a source file or directory, run the following command:

```
aidoc gen <source_file>
```

You can also specify the following optional arguments:

- `-o` or `--overwrite`: Overwrite existing docstrings
- `-f` or `--format`: Format the entire source file using black (default=True)
- `-pr` or `--pull-request`: Create a pull request with the changes

## Examples

**Generate docstrings for the main.py file:**

```
aidoc gen main.py
```

**Generate docstrings for all Python files in the src directory and its subdirectories:**

```
aidoc gen src
```

**Generate docstrings and create a pull request with the changes:**

```
aidoc gen main.py -pr
```

## Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

## License

This project is licensed under the GNU General Public License v3.0 - see the [LICENSE](LICENSE) file for details.

## Acknowledgments

* [OpenAI](https://openai.com/)

## Disclaimer

This project is not affiliated with OpenAI. The OpenAI API and GPT-3 language model are not free. You will need to sign up for a free [OpenAI](https://beta.openai.com/) account and create an API key to use this tool.
JSGFToolsLeyzer 0.2.0
Tools for JSGF grammar expansion.
Requires Python: >=3.7

JSGF Grammar Tools for Leyzer corpus
====================================

Introduction
============

This library generate strings from a JSGF grammar. Although it can be used to generate
strings from any JSGF grammar it was created as auxilary tool for Leyzer
(<https://github.com/cartesinus/leyzer>) grammars generation. It is slightly modified
version of <https://github.com/syntactic/JSGFTools>.

Notes:
- Larger grammars take a longer time to parse, so if nothing seems to be generating,
wait a few seconds and the grammar should be parsed.
- Most of JSGF as described in http://www.w3.org/TR/2000/NOTE-jsgf-20000605/ is
supported, but there are a few things that have not been implemented by these
tools yet:
    - Kleene operators
    - Imports and Grammar Names
    - Tags

Dependencies:
- Python 3.7
- PyParsing 3.0.9

JSGFTools were originaly created by Pastèque Ho (and others).

Library Usage
=============

To generate strings from grammar use it as in below example. Below example use
grammar that is included in this repository. Other, more complex grammars, can
be found in <https://github.com/cartesinus/leyzer> repository.

```python
from from JSGFToolsLeyzer import parser

fs = open("Ideas.gram")
grammar = parser.getGrammarObject(fs)

for rule in grammar.publicRules:
    expansions = processRHS(rule.rhs, grammar)
    for expansion in expansions:
        print(expansion)
```

License
=======

MIT License.
package-logger 1.0.0
Logger for Python
Keywords: python3-logger logger debugging print


This Package can be used from Debugging purposes.
When you are working in long project, you often use print statement for debugging purposes.
Sometime, you use to many print statement and after completing debugging you spent sometime to find and remove all those previous print statement

What does this package do?
When you print something for debugging purposes using this package, it will print out in following pattern

[TYPE_OF_WARNING] -> TextType (INFO, WARNING, etc)
[From] -> Which method is calling this packages' method
[Line] -> On which line is it calling
[Statement(s)] -> Print all the messages you have writen

You can even pass multiple texts as parameters just like in print statement

Example
from package_logger import LoggerClass, TextType

logger = LoggerClass()
logger.print("Hello", "World", type_ = TextType.INFO)

You can use colorPrint method instead of print method to print with color for different messages type
Example
from package_logger import ColorType
logger.colorPrint("Hello", "World", type_ = TextType.INFO, color = ColorType.COLOR_INFO)
myapiframework 1.0
eazy python framework

# Myapi framework

Eazy python framework for beginers

> pip install myapiframework


```python
# main.py
from myapiframework import MyAPI
from myapiframework import Response
from myapiframework import parse_json, parse_form

app = MyAPI()


@app.get('/')
def home(request):
    data = {'message': 'hello'}
    return Response(status=200, data=data)

# get post with id 
@app.get('/post/{id}/')
def get_post(request, id):
    post = {
        'id': id,
        'name': 'myapi',
        'description': 'new framework myapi'
    }
    return Response(status=200, data=post)


# create post
@app.post('/post/')
def create_post(request):
    if request.content_type == 'application/json':
        data = parse_json(request.data)
        return Response(status=201, data=data)
    data = parse_form(request.data, request)
    return Response(status=201, data=data)
```

> gunicorn main:app

### methods:
- get
- post
- put
- patch
userinputgetter 1.1.0
Provides an interface, and several implementations, of classes which continuously request command-line user input until a valid response has been attained, and parse the output as a desired type
Requires Python: >=3.7

# UserInputGetter

This package provides an interface, and several implementations, of classes which continuously request command-line user input until a valid response has been attained, and parse the output as a desired type.

The input is checked for validity (for example if a date is expected, the input must match one of several supported date regular expressions), and optionally a user may specified an iterable of supported options, in which case the user input must be parsable as one of the specified options.

The implementations provide two main methods for interacting with user input. The first is `get_value()`, and the second is `get_multiple_values()`, which parses multiple user inputs when provided as a comma-separated list

The abstract base class is called `UserInputGetter`, and the following implementations are provided:

## Implementations

* `IntegerInputGetter`
* `CaseInsensitiveStringInputGetter`
* `DateInputGetter`

## Download from the Python Package Index

* `pip install userinputgetter`
* https://pypi.org/project/userinputgetter/1.0.0/