semvec/pypi-packages huggingface dataset:
aws-flask-lambda-swagger-ui 0.1.4
Adding swagger ui on your AWS Lambda Function using a Flask blueprint

# aws_flask_lambda_swagger_ui

Version 0.1.3 includes the templates folder and uses Flask v3.0.3 and werkzeug v3.0.3

## Installation

Install the package using pip:

```sh
pip install aws-flask-lambda-swagger-ui
```

## Usage

```python
from flask import Flask
from aws_flask_lambda_swagger_ui import get_swaggerui_blueprint

app = Flask(__name__)

SWAGGER_URL = '/aws/test/docs' 
API_URL = 'https://petstore.swagger.io/v2/swagger.json' 

swaggerui_blueprint = get_swaggerui_blueprint(
    SWAGGER_URL,  
    API_URL,
    config={  
        'app_name': "AWS Lambda application"
    }
)

app.register_blueprint(swaggerui_blueprint, url_prefix=SWAGGER_URL)

if __name__ == '__main__':
    app.run(debug=True)

```

When the Flask app is running, just access the swagger url:
```
http://localhost:5000/aws/test/docs/
```
taipan-assistant 1.0.5
Package provides a simple CLI tool to be used as a personal assistant
Requires Python: <4,>=3.7

# Address Book Bot
## Description
This bot is designed for managing contacts and birthdays in an address book. It supports a set of commands for creating, modifying, and viewing contacts and birthdays.

## Installation
1.Ensure you have Python 3.6 or higher installed.
2.Install the necessary dependencies if any (e.g., if using prompt_toolkit):

pip install prompt_toolkit

## Running the Bot
To run the bot, use the following command:
python main.py

## Commands
Here is a list of available commands and their descriptions:

- help: Prints a list of available commands.
- hello: Prints a greeting message.
- add [name] [phone number]: Creates a new contact with the specified phone number.
- change [name] [phone number]: Changes the phone number of an existing contact.
- phone [name]: Prints the phone number of the specified contact.
- all: Prints all contacts.
- add-birthday [name] [birthday]: Adds a birthday to the specified contact.
- show-birthday [name]: Prints the birthday of the specified contact.
- birthdays: Prints all birthdays.
- close or exit: Terminates the program.

## Usage Examples
- To add a new contact:
>> add John 123-456-7890
- To change a contact's phone number:
>> change John 987-654-3210
- To view a contact's phone number:
>> phone John
- To add a birthday to a contact:
>> add-birthday John 1990-01-01
- To view a contact's birthday:
>> show-birthday John
- To exit the program:
>> close
>> exit
pysynchronizer 1.0
A class or decorator to help with asynchronous programming in Python within synchronous contexts.
Requires Python: >=3.7

# Asynchronizer

This repository contains a Python decorator and class that allow you to run asynchronous code from a synchronous context. This can be particularly useful when you need to perform IO-bound tasks such as making HTTP requests, reading from or writing to a database, or interacting with the file system, but you are working within a synchronous context.

## Installation

You can install the `asynchronizer` package using pip. Open your terminal and type:

```bash
pip install pysynchronizer
```

## Usage

Here are some examples of how you can use the `asynchronizer` package.

### Using the decorator

```python
from asynchronizer import asynchronize

@asynchronize
async def async_function():
    # Your asynchronous code here

async_function()
```

In the above example, `async_function` is an asynchronous function decorated with `@async_to_sync`. This allows it to be called from a synchronous context.

### Using the class

```python
from asynchronizer import Asynchronizer

async def async_function():
    # Your asynchronous code here

asynchronizer = Asynchronizer()
asynchronizer.run(async_function())
asynchronizer.run_async(async_function())
```

In this example, an instance of `Asynchronizer` is created. The `run` or `run_async` method is then used to execute `async_function` from a synchronous context.

## Contributing

Contributions are welcome! Please read the [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute to this project.

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details.
yappd 0.1.0
Add your description here
Requires Python: >=3.8

# yappd

This is a persistent dictionary like object in Python based on `jsonpickle` and `sqlite3`. You store values in it like a normal `dict` and they are written to disk automatically. When you load it up again later, everything is like you left it.

## Why?

Pickling objects in Python has some major downsides. With `jsonpickle` we get human readable output that can always be loaded, even if the original classes aren't around in the current scope.

But why not just store the resulting JSON to disk in a text file? Well, it turns out that reliably updating files on disk in an atomic way is not so easy. SQLite has this covered and is a no brainer choice for storing app data on disk.

That said, if you don't need SQL features, then adopting a database brings a lot of extra hassle (even with an ORM). The implementation of yappd means we can just shove arbitrary objects into the disk and get them back later. There's no need to perform a database migration if you decide later that every `Pet` object should have a `favorite_food` field.

## How to use it?

No package yet. For now you can just drop (or symlink) the file from this repo into your project and make sure to install `jsonpickle`:

```
pip install jsonpickle
```

Then import and use PDict:

```python
from pdict import PDict
p = PDict('mydata')
p['hello'] = 'world'
```

Each PDict needs a file to write its data into, and the path to the file is the first argument to the constructor. An optional second argument is the dictionary name, which allows multiple dictionaries to be stored in the same file. By default the name `default` used:

```python
p1 = PDict('mydata', 'default') # Equivalent to example above
p2 = PDict('mydata', 'p2') # This one uses p2 as the name so there's no conflict
```

## Caveat, data mutation

There's a major caveat to keep in mind, which is mutable data types. Take this usage for example:

```python
p = PDict('mydata')
p['mylist'] = []
p['mylist'].append(1)
assert p['mylist'] == [1]
p = PDict('mydata') # Reload the dict from disk
assert p['mylist'] == [] # Change not stored to disk
```

At this point the value stored on disk for `mylist` is an empty list, but the value stored in the program memory is `[1]`. Since yappd doesn't make any effort to detect if data is mutated after it's added (if this is even possible), you must explicitly store any mutated values again to update them on disk.

```python
p = PDict('mydata')
p['mylist'] = []
p['mylist'] = p['mylist'].append(1)
assert p['mylist'] == [1]
p = PDict('mydata')
assert p['mylist'] == [1] # This time it's okay
```

I plan to add a couple of helper functions to make working with mutable data types more ergonomic. It will still fall on the user to understand they are mutating data and ensure mutations are stored to disk.
llmgen 0.4.0
Effortlessly generate LLM APIs by simply defining input and output schemas.
Requires Python: <4.0.0,>=3.8.1

# llmgen

[![PyPI](https://img.shields.io/pypi/v/llmgen?label=pypi%20package)](https://pypi.org/project/llmgen/)

Effortlessly generate LLM APIs by simply defining input and output schemas (by pydantic).


## Quick Start

Example:

```python
from llmgen import OpenAiApiFactory

factory = OpenAiApiFactory(
    api_key="your api key here",
)

@llm.impl()
def make_joke(theme: str) -> str
    """generate a random short joke based on theme""" # just describe your api in docstring
    ...

# call it just like you implmented it. 

res = make_joke('cat')
print(res)

# >>> "Why was the cat sitting on the computer? It wanted to keep an eye on the mouse!"

```

checkout /demo to see more example.
Primer-Proyecto-Hackeno 0.7.0
Una biblioteca para consultar los distintos cursos de la academia Hack4u.

# Hack4u Academy Courses Library

Una biblioteca Python para consultar los cursos de la academia Hack4u.

## Cursos disponibles:

- Introducción a Linux [15 horas]
- Personalización de Linux [3 horas]
- Introducción al Hacking [53 horas]

## Instalación

Instala el paquete utilizando `pip3`:

```python3
pip3 intall Primer_Proyecto_Hackeno
```

# Uso básico

## Listar todos los cursos

```python
from Primer_Proyecto_Hackeno import list_courses

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

## Obtener un curso por nombre

```python
from Primer_Proyecto_Hackeno import get_course_by_name

course = get_course_by_name("Introducción a Linux")
print(course)
```

## Calcular la duración total de los cursos

```python3
from Primer_Proyecto_Hackeno.utils import total_duration

print(f"Duración total: {total_duration()} horas")
```
booleabayes 1.0.0
A suite for network inference from transcriptomics data
Requires Python: >=3.6

=======================================================
BooleaBayes
=======================================================
.. image:: https://badge.fury.io/py/booleabayes.svg
    :target: https://pypi.org/project/booleabayes/
    :alt: Latest PYPi Version

BooleaBayes is a suite of network inference tools to derive and simulate gene regulatory networks from transcriptomics data. To see how BooleaBayes could be applied to your own data, see our publication in PLOS Computational Biology, `Wooten, Groves et al. (2019) <https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1007343>`_. 


Installation
~~~~~~~~~~~~~~~~~

To install ``BooleaBayes``, please use::

    pip install booleabayes

Dependencies
---------------------

The ``graph-tool`` python package will need to be installed. This can be installed with `Conda`, `homebrew`, etc as seen `here <https://git.skewed.de/count0/graph-tool/-/wikis/installation-instructions>`_. All other dependencies will be installed with this package.

BooleaBayes Usage:
~~~~~~~~~~~~~~~~~~~~~~~~

* ``net`` = make or modify network structure
* ``load`` = loading data
* ``proc`` = processing
* ``rw`` = random walk
* ``plot`` = plotting
* ``tl`` = tools
* ``utils`` = utilities
Primer-Proyecto-Hacke-o 0.5.0
Una biblioteca para consultar los distintos cursos de la academia Hack4u.

# Hack4u Academy Courses Library

Una biblioteca Python para consultar los cursos de la academia Hack4u.

## Cursos disponibles:

- Introducción a Linux [15 horas]
- Personalización de Linux [3 horas]
- Introducción al Hacking [53 horas]

## Instalación

Instala el paquete utilizando `pip3`:

```python3
pip3 intall Primer_Proyecto_Hackeño
```

# Uso básico

## Listar todos los cursos

```python
from Primer_Proyecto_Hackeño import list_courses

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

## Obtener un curso por nombre

```python
from Primer_Proyecto_Hackeño import get_course_by_name

course = get_course_by_name("Introducción a Linux")
print(course)
```

## Calcular la duración total de los cursos

```python3
from Primer_Proyecto_Hackeño.utils import total_duration

print(f"Duración total: {total_duration()} horas")
```
Primer-Proyecto-Academia 0.5.0
Una biblioteca para consultar los distintos cursos de la academia Hack4u.

# Hack4u Academy Courses Library

Una biblioteca Python para consultar los cursos de la academia Hack4u.

## Cursos disponibles:

- Introducción a Linux [15 horas]
- Personalización de Linux [3 horas]
- Introducción al Hacking [53 horas]

## Instalación

Instala el paquete utilizando `pip3`:

```python3
pip3 intall Primer_Proyecto_Hackeño
```

# Uso básico

## Listar todos los cursos

```python
from Primer_Proyecto_Hackeño import list_courses

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

## Obtener un curso por nombre

```python
from Primer_Proyecto_Hackeño import get_course_by_name

course = get_course_by_name("Introducción a Linux")
print(course)
```

## Calcular la duración total de los cursos

```python3
from Primer_Proyecto_Hackeño.utils import total_duration

print(f"Duración total: {total_duration()} horas")
```