semvec/pypi-packages huggingface dataset:
drf-openapi-schema 0.0.3
Django Rest Framework OpenAPI Schema generation.
License: MIT
Requires Python: >=3.9,<4
Keywords: drf,django,rest_framework,rest,framework,openapi,schema,generator

# Django Rest Framework OpenAPI Schema

[![Coverage Status][coverage-badge]][coverage]
[![GitHub Workflow Status][status-badge]][status]
[![PyPI][pypi-badge]][pypi]
[![GitHub][licence-badge]][licence]
[![GitHub Last Commit][repo-badge]][repo]
[![GitHub Issues][issues-badge]][issues]
[![Downloads][downloads-badge]][pypi]
[![Python Version][version-badge]][pypi]

```shell
pip install drf-openapi-schema
```

---

**Documentation**: [https://mrthearman.github.io/drf-openapi-schema/](https://mrthearman.github.io/drf-openapi-schema/)

**Source Code**: [https://github.com/MrThearMan/drf-openapi-schema/](https://github.com/MrThearMan/drf-openapi-schema/)

**Contributing**: [https://github.com/MrThearMan/drf-openapi-schema/blob/main/CONTRIBUTING.md](https://github.com/MrThearMan/drf-openapi-schema/blob/main/CONTRIBUTING.md)

---

...

[coverage-badge]: https://coveralls.io/repos/github/MrThearMan/drf-openapi-schema/badge.svg?branch=main
[status-badge]: https://img.shields.io/github/actions/workflow/status/MrThearMan/drf-openapi-schema/test.yml?branch=main
[pypi-badge]: https://img.shields.io/pypi/v/drf-openapi-schema
[licence-badge]: https://img.shields.io/github/license/MrThearMan/drf-openapi-schema
[repo-badge]: https://img.shields.io/github/last-commit/MrThearMan/drf-openapi-schema
[issues-badge]: https://img.shields.io/github/issues-raw/MrThearMan/drf-openapi-schema
[version-badge]: https://img.shields.io/pypi/pyversions/drf-openapi-schema
[downloads-badge]: https://img.shields.io/pypi/dm/drf-openapi-schema

[coverage]: https://coveralls.io/github/MrThearMan/drf-openapi-schema?branch=main
[status]: https://github.com/MrThearMan/drf-openapi-schema/actions/workflows/test.yml
[pypi]: https://pypi.org/project/drf-openapi-schema
[licence]: https://github.com/MrThearMan/drf-openapi-schema/blob/main/LICENSE
[repo]: https://github.com/MrThearMan/drf-openapi-schema/commits/main
[issues]: https://github.com/MrThearMan/drf-openapi-schema/issues
renault-api-lite 0.8.2
Lightweight Python API for querying status info for a variety of Renault vehicle models
License: MIT
Requires Python: >=3.10
Keywords: Renault Z.E. ZOE Twingo Megane Kangoo Electric vehicle EV status API

# [renault API (lite)](https://github.com/bkogler/renault-api-lite)
Lightweight Python API for querying status info for a variety of Renault vehicle models

# Features
Conveniently read status info for Renault vehicles (e.g. EVs), including:

* battery status (level, autonomy, plug status, temperature, ...)
* charging configuration / charge schedule
* fuel autonomy (for combustion vehicles)
* HVAC / pre-conditioning status
* GPS location

# Installation
`pip install renault-api-lite`

# Usage Examples

## Query battery status
````python
from renault import RenaultVehicleClient

car = RenaultVehicleClient(
    login_id="Your E-Mail", password="Your password", # --> change to your credentials
    account_locale="de_DE" # --> optional
)

# get battery status
status = car.get_status(car.STATUS_BATTERY_ONLY)
````
#### Hint: Pretty Print Status
````python
import json

print(json.dumps(status, indent=4))
````
````
{
    "battery_status_data": {
        "timestamp": "2022-08-145T07:24:12Z",
        "battery_level": 90,
        "battery_temperature": 25,
        "battery_autonomy": 207,
        "battery_capacity": 0,
        "battery_available_energy": 20,
        "plug_status": 0,
        "charging_status": -1.1,
        "charging_remaining_rime": 10,
        "charging_instantaneous_power": 0.0
    }
}
````

## Query custom data selection (battery and cockpit data)
````python
# get battery status, cockpit data
status = car.get_status((
    car.StatusType.BATTERY,
    car.StatusType.COCKPIT,
))
````
#### Hint: Pretty Print Status
````python
import json

print(json.dumps(status, indent=4))
````
````
{
    "battery_status_data": {
        "timestamp": "2022-08-145T07:24:12Z",
        "battery_level": 90,
        "battery_temperature": 25,
        "battery_autonomy": 207,
        "battery_capacity": 0,
        "battery_available_energy": 20,
        "plug_status": 0,
        "charging_status": -1.1,
        "charging_remaining_rime": 10,
        "charging_instantaneous_power": 0.0
    },
    "cockpit_data": {
        "fuel_autonomy": null,
        "fuel_quantity": null,
        "total_mileage": 1234.22
    }
}
````

# Disclaimer
This project is not affiliated with, endorsed by, or connected to Renault. I accept no responsibility for any consequences, intended or accidental, as a result of interacting with Renault's API using this project.

# Credits
This project is based on [hacf-fr's renault-api](https://github.com/hacf-fr/renault-api) for Python

# Links
[renault-api-lite GitHub repository](https://github.com/bkogler/renault-api-lite)

[renault-api-lite on PyPi](https://pypi.org/project/renault-api-lite/)

[hacf-fr's renault-api](https://github.com/hacf-fr/renault-api)
sarf-simple-crud 0.1.0
An extremely simple and basic interface for creating CRUD apps with an example of implementation using a JSON database.
License: MIT

# SimpleCRUD

An extremely simple and basic interface for creating CRUD apps
with an example of implementation using a JSON database.

This project comes from splitting SARF into multiple modules.

## Support my work

If this module has been useful to you, it would mean a lot to me if you could support my work.
This way you help to keep this and other projects alive.

- https://ko-fi.com/elchicodepython

## Contributors

- Samuel López Saura - [Linkedin Contact](https://es.linkedin.com/in/sam-sec)
text-analysis-helpers 0.6.0
Collection of classes and functions for text analysis
License: MIT
Requires Python: >=3.10,<4.0
Keywords: text analysis

# Introduction

Text-analysis-helpers is a collection of classes and functions for text analysis.

# Installation

A Python 3 interpreter is required. It is recommended to install the package in
a virtual environment in order to avoid corrupting the system's Python interpreter
packages.

Install the package using pip.

```bash
pip install text-analysis-helpers

python -m nltk.downloader "punkt"
python -m nltk.downloader "averaged_perceptron_tagger"
python -m nltk.downloader "maxent_ne_chunker"
python -m nltk.downloader "words"
python -m nltk.downloader "stopwords"
```

# Usage

You can use the HtmlAnalyser object to analyse the contents of a url.

```python
from text_analysis_helpers.html import HtmlAnalyser

analyser = HtmlAnalyser()
analysis_result = analyser.analyse_url("https://www.bbc.com/sport/formula1/64983451")

analysis_result.save("analysis_result.json")
```

You can see the scripts in the `examples` folder for some usage examples.

There is also an cli utility that can be used to analyse a url. For example to
analyse a url and save the analysis result to a json encoded file execute the
following command in the terminal.

```bash
text-analysis-helpers-cli analyse-url --output analysis_result.json https://www.bbc.com/sport/formula1/64983451
```
getdefgw 0.0.2
get default gateway device / IP
License: MIT
Requires Python: >=3

# defgw
Get default gateway interface / IP (for Linux)

Parses/decodes /proc/net/route and prints def gw information

## Install
~~~
pip3 install getdefgw
~~~

## Usage
~~~
$ getdefgw 
192.168.100.245

$ getdefgw --dev
wlp8s0
~~~
sysexecute 1.2.1
A library for simplified executing of system commands
License: MIT
Keywords: execute,shell,system

## Purpose

The sysexecute python package allows the easier execution of system tasks. Part of this is an auto-formatting mechanism for variable substitution, part of this is being able to simply specify the execution options.

## Installation

You can install `sysexecute` from PyPi via pip:

```
pip install sysexecute
```

## Variable Substitution

Typically in python to format a string we might do something like:

```
val = 3
print("the value of val is {val}".format(val=val))
```

This is kind of long and redundant. If we already have a value for `val` then it should be able to just be substituted. In fact if we do

```
from sysexecute import *
val = 3
print (stringWithVars("the value of val is {val}"))
```

The bindings for the variables follow normal python scoping rules. This makes the execution statements a good bit more readable.

## Execution

Here is a typical execution

```
execute("ssh {machineIP} ls {thePath}")
```
assuming the variable `machineIP` and `thePath` have values. The normal output of this script gets piped to StdOut and StdErr, but if you want to capture these you can with something like:

```
(rc, stdout, stderr) = execute("ssh {machineIP} ls {thePath}", captureStdOutStdErr=True)
```

There are various keyword options you can specify like:

- `cwd` : change the directory from which the command will be executed
- `ignoreErrors`: Unless this is true a `sys.exit(returnCode)` will be issued if there is a non-zero return code.
- `shell`: if a shell should be used (defaults to `True`)
- `executable`: which shell to use (defaults to `/bin/bash`)
- `colorize`: wether to colorize the output (defaults to `True`)
- `dryRun` : print what would be executed but don't actually execute anything

## Verbosity

Often in scripting we want to include debugging / info commentary depending on what level of verbosity we are requested to display. You can set the level of verbosity shown via eg:

```
set_execute_defaults('verbosity',2)
```

Then in the following only the first two strings would be printed:

```
printWithVars1("success!")
printWithVars2("Machine {machineIP} was reached.")
printWithVars3("You might want to check that blah and blah.")
```


## Testing

To run the test suite you need `py.test` installed on your machine. Then you can simply execute:

```
cd tests
py.test
```