semvec/pypi-packages huggingface dataset:
aqualink-api 1.0.8
Aqualink API documentation
Requires Python: >=3.6
Keywords: OpenAPI,OpenAPI-Generator,Aqualink API documentation

# aqualink-api
The Aqualink public API documentation

This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project:

- API version: 1.0.0
- Package version: 1.0.8
- Build package: org.openapitools.codegen.languages.PythonClientCodegen

## Requirements.

Python >=3.6

## Installation & Usage
### pip install

If the python package is hosted on a repository, you can install directly using:

```sh
pip install aqualink-api
```
(you may need to run `pip` with root permission: `sudo pip install git+https://github.com/GIT_USER_ID/GIT_REPO_ID.git`)

Then import the package:
```python
import aqualink_sdk
```

### Setuptools

Install via [Setuptools](http://pypi.python.org/pypi/setuptools).

```sh
python setup.py install --user
```
(or `sudo python setup.py install` to install the package for all users)

Then import the package:
```python
import aqualink_sdk
```

## Getting Started

Please follow the [installation procedure](#installation--usage) and then run the following:

```python

import time
import aqualink_sdk
from pprint import pprint
from aqualink_sdk.api import collections_api
from aqualink_sdk.model.collection import Collection
from aqualink_sdk.model.create_collection_dto import CreateCollectionDto
from aqualink_sdk.model.inline_response401 import InlineResponse401
from aqualink_sdk.model.inline_response404 import InlineResponse404
from aqualink_sdk.model.update_collection_dto import UpdateCollectionDto
# Defining the host is optional and defaults to https://ocean-systems.uc.r.appspot.com/api
# See configuration.py for a list of all supported configuration parameters.
configuration = aqualink_sdk.Configuration(
    host = "https://ocean-systems.uc.r.appspot.com/api"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure Bearer authorization (JWT): bearer
configuration = aqualink_sdk.Configuration(
    access_token = 'YOUR_BEARER_TOKEN'
)


# Enter a context with an instance of the API client
with aqualink_sdk.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = collections_api.CollectionsApi(api_client)
    create_collection_dto = CreateCollectionDto(
        name="La Niña heatwave 20/21",
        user_id=1,
        site_ids=[1,3,5],
        is_public=True,
    ) # CreateCollectionDto | 

    try:
        # Creates a new collection
        api_response = api_instance.collections_controller_create(create_collection_dto)
        pprint(api_response)
    except aqualink_sdk.ApiException as e:
        print("Exception when calling CollectionsApi->collections_controller_create: %s\n" % e)
```
swagger-dialect 0.0.3
Swagger definition SQLAlchemy reflection
Requires Python: >3.10.0
Keywords: import,physical address,file path

# swagger-dialect
SQLAlchemy Swagger definition reflection 

*Swagger_DBAPI* : DBAPI compatible class that returns Swagger model definitions as:
* Tables
* Columns
* Foreign key relationships

Very important to Note, currently a primary key identity column `id` is added to each extracted table definition

*SwaggerDialect* : SQLAlchemy dialect which can translate the schema extraction via Swagger_DBAPI into valid SQLAlchemy MetaData

Python 10 support only as use is made of the new match statement syntax

Here is an example where Python code is generated for SQLAlchemy from the Swagger definitions. (sqlacodegen>=3.0rc1)

```python
import logging
import argparse
import sys
from contextlib import ExitStack
from typing import TextIO
from sqlalchemy.engine import create_engine
from sqlalchemy.schema import MetaData
from sqlacodegen.generators import DeclarativeGenerator

from swagger_dialect import register_swagger_dialect

LOGGING_FORMAT = "[%(levelname)1.1s %(asctime)s.%(msecs)03d %(process)d %(module)s:%(lineno)d %(name)s] %(message)s"

register_swagger_dialect()


def get_args():
    parser = argparse.ArgumentParser(
        description="Generates SQLAlchemy model code from an existing database."
    )
    parser.add_argument(
        "--option", nargs="*", help="options passed to the generator class"
    )
    parser.add_argument(
        "--version", action="store_true", help="print the version number and exit"
    )
    parser.add_argument(
        "--schemas", help="load tables from the given schemas (comma separated)"
    )
    parser.add_argument(
        "--tables", help="tables to process (comma-separated, default: all)"
    )
    parser.add_argument("--noviews", action="store_true", help="ignore views")
    parser.add_argument("--outfile", help="file to write output to (default: stdout)")
    return parser.parse_args()


def run_reflection(url, model_file_name=None):

    # Use reflection to fill in the metadata
    engine = create_engine(url)
    metadata = MetaData()
    tables = None
    incl_views = False
    schemas = [None]
    for schema in schemas:
        metadata.reflect(engine, schema, incl_views, tables)

    args = get_args()
    generator = DeclarativeGenerator(metadata, engine, set(args.option or ()))

    # Open the target file (if given)
    with ExitStack() as stack:
        outfile: TextIO
        if model_file_name:
            outfile = open(model_file_name, "w", encoding="utf-8")
            stack.enter_context(outfile)
        else:
            outfile = sys.stdout
        outfile.write(generator.generate())

if __name__ == "__main__":
    run_reflection(url='swagger://MyAppSwagger.yaml', model_file_name="generated_model.py")

```
pytello-hsu 3.0.0
A package to make it easier to fly your tello drone in python
Requires Python: >=3.0

# Read Me
For this  to work you need Python 3.6 and above and Windows 10. At the begining of the your file you create you need to add the following command:

import pytello-hsu

Also to get this on your computer you need to do the following command:

pip install pytello-hsu

When programming you must use the "init()" command at the begining of the file if you want the program to work unless you know what your doing and how the program works. To undersand how the program works further look at DOCUMENTATION.md.
inspect-requirements 0.10.7
Inspect requirements.txt files of multiple repositories.
Keywords: requirements,pip

# Inspect requirements

Inspect requirements is tool indendend to make it easier to compare requirements.txt files between multiple projects/applications.

Basic usage:

```sh

# e.g. in a directory structure as follows:

$ find .
./project1
./project1/requirements.txt
./project3
./project3/requirements-prod.txt
./project2
./project2/requirements
./project2/requirements/dev.txt


# ..output would be like this:

$ inspect-requirements

Type a number or "q" to continue >a

Select repositories (or "a" for all)
* 1: project1
* 2: project3
* 3: project2

--- Summary ---
fastapi, 2 different versions
  * project1/requirements.txt: "==0.75.0"
  * project3/requirements-prod.txt: "==0.74.0"
  * project2/requirements/dev.txt: "==0.74.0"
starlette, 1 different versions
  * project1/requirements.txt: "==0.19.1"
  * project3/requirements-prod.txt: "==0.19.1"
  * project2/requirements/dev.txt: "==0.19.1"
psycopg2, 2 different versions
  * project1/requirements.txt: "==2.9.3"
  * project3/requirements-prod.txt:
  * project2/requirements/dev.txt: "==2.9.3"
pytz, 1 different versions
  * project2/requirements/dev.txt: "==2022.1"

```
lightweb4py 0.1.0b1
A lightweight web framework with Router, CBV, ORM and Logger
Requires Python: >=3.7
Keywords: development wsgi orm cbv logger

# lightweb4py - A lightweight WSGI framework with Router, CBV, ORM and Logger

This framework allows for rapid development of applications to deal with HTTP requests from a WSGI server. 
It implements:
- request routing to CBV's (Class-Based Views) that can use Jinja2 templating engine, 
- basic ORM (Object-Relational Mapping) functionality with interfaces to JSON and SQLite, and
- Logger functionality with console and CSV file output. 
There's also a demo app aimed to demonstrate the framework's capabilities (demo/ folder).

Detailed framework description is available in its documentation (in Russian language only) (docs/README.md).

Description of the demo app is presented in its documentation (in Russian language only) (demo/docs/README.md).

# lightweb4py - Легкий WSGI-фреймворк с маршрутизацией, CBV, ORM и логгером

Фреймворк позволяет с минимальными затратами разработать приложение для работы с HTTP-запросами от 
WSGI-сервера и реализует:
- функциональность маршрутизации запросов в классы-обработчики CBV (Class-Based Views), 
использующие шаблонизатор Jinja2, 
- механизм ORM (Object-Relational Mapping, объектно-реляционное отображение данных) с интерфейсом к JSON и SQLite, 
а также
- логгер с отображением логов на консоль и сохранением их в текстовый файл CSV. 
Также реализовано демонстрационное приложение для демонстрации возможностей фреймворка (папка demo/).

Детальное описание фреймфорка приведено в его документации (docs/README.md).

Описание демонстрационного приложения приведено в его документации (demo/docs/README.md).
pyNutriScore 0.0.2
Nutri-Score, an indicator of nutritional quality
Requires Python: >=3.7

# pyNutriScore

<p align="center">
  <img width="568" height="307" src="https://raw.githubusercontent.com/lemonhead94/pyNutriScore/main/assets/images/nutri-score-logo.png" alt="Nutri Score logo">
</p>

> The goal of the project is to provide simple package that can calculate the Nutri-Score.

## What is the Nutri-Score ?

The Nutri-Score is a nutrition label that converts the nutritional value of products into a simple code consisting of 5 letters, each with its own colour.

Each product is awarded a score based on a scientific algorithm.

This formula takes into account the nutrients to avoid (energy value and the amount of sugars, saturated fats and salt) and the positive ones (the amount of fibre, protein, fruit, vegetables and nuts).

You can therefore see at a glance which products are recommended and which should be avoided.

> Source: <https://nutriscore.colruytgroup.com/colruytgroup/en/about-nutri-score/>

Paper: <https://pdfs.semanticscholar.org/3d1c/c206bc286bb5f80452821a0d26ff9e55b387.pdf>

## Where to get it
The source code is currently hosted on GitHub at:
https://github.com/lemonhead94/pyNutriScore

## Usage

### Install

```sh
pip install pyNutriScore
```

### Calculate the nutri-score:

```python
from pyNutriScore import NutriScore

result = NutriScore().calculate(
    {
        'energy': 0,
        'fibers': 4,
        'fruit_percentage': 60,
        'proteins': 2,
        'saturated_fats': 2,
        'sodium': 500,
        'sugar': 10,
    },
    'solid'  # either 'solid' or 'beverage'
)

print(result)  # Output: 2
```

### Calculate the nutri-score class:

```python
from pyNutriScore import NutriScore

result = NutriScore().calculate_class(
    {
        'energy': 0,
        'fibers': 4,
        'fruit_percentage': 60,
        'proteins': 2,
        'saturated_fats': 2,
        'sodium': 500,
        'sugar': 10,
    },
    'solid'  # either 'solid' or 'beverage'
)

print(result)  # Output: "B"
```

## License
[MIT](LICENSE)

## Contribution

Feel free to add suggestions, PRs, comments and bug reports.

## Credits
This is a re-implementation of the TypeScript package [nutri-score](https://github.com/food-nutrients/nutri-score/) by [Alex Kolarski](aleks.rk@gmail.com) in Python.

## Authors

Jorit Studer (jorit.studer@gmail.com)