semvec/pypi-packages huggingface dataset:
easy-regression 0.1.1
A tool for running and analyzing regression tests
Requires Python: >=3.6

# Deepan's Regression Tool

## Overview

Deepan's Regression Tool is designed to automate regression testing by running commands specified in an Excel file and logging the results. This tool is especially useful for managing large-scale testing environments where multiple test cases need to be executed and monitored.

## Features

- Executes commands specified in an Excel file.
- Logs the results of each command.
- Handles various error scenarios and retries failed commands.
- Updates the Excel file with the status of each command.

## License

This tool is licensed under the GNU General Public License v3.0. For more details, visit: [GNU GPL v3.0](https://www.gnu.org/licenses/gpl-3.0.en.html).

## Installation

To use this tool, install it via pip:

```sh
pip3 install deepan_regression_tool
```
## Prerequisites
- Python >=3.9
- openpyxl
- Linux operating system

## Usage
Importing the Module
After installation, you can import the module as follows:
```python
import deepan_regression_tool
```
## Running Regression
To run the regression, use the run_regression function provided by the module.

```python
import deepan_regression_tool

def check_results (input1, input2):
    ...
    ...
    ...
    return [flag, status]

deepan_regression_tool.check_results = check_results

deepan_regression_tool.regression(json_file_name,number_of_iteratables,max_bit_widths1,max_bait_widths2,iteratable_freq,random_iteratable_values,timeout_for_run_command)

help = deepan_regression_tool.HELP_MESSAGE
```
flag can take boolean values - True,Flase
status can take string values - PASS,FAIL,terminate,try_again,clean_db_try_again

## Fair Use
This tool is provided as-is under the GNU General Public License v3.0. You are free to use, modify, and distribute this tool, provided that you adhere to the terms of the license. For more details, visit: GNU GPL v3.0.

## Contact
For questions or suggestions, please open an issue on the GitHub repository.
dj-db-rotated-secret 0.1.1
AWS Secrets has a auto-rotation feature, but Django doesn't support it out of the box. This package provides a way to rotate the secret in Django settings.
Requires Python: >=3.10

# DJ DB Rotated Secret

AWS Secrets auto-rotation will cause a `password authentication failure` in Django that is unhandled.

This is a low level wrapper around Django's `_cursor` and `connect` db functions to handle and and allow graceful rotation.

## WARNING

This is very much an alpha release. Jenfi uses it in production, but it is entirely suited to our needs. PRs welcome to expand the capabilities.

## Things to Know

- Postgres only via psycopg 2 & 3
- It is a monkey patch and can only be added via installed_apps.
  - i.e. if a password gets rotated _after_ django loads but _before_ this library gets loaded _while_ another app makes a DB connection, the password error won't get caught. Extremely narrow window.
- This library does not know/care about how to obtain the updated password. Simply tell it a function path to run and it will call it assuming a return dict of:

  ```python
  {
    "username": "...",
    "password": "...",
  }
  ```

## Install

1. `poetry add dj-db-rotated-secret`
1. Add to installed apps, below django and above other apps.

   ```python
       INSTALLED_APPS = [
         ...
         "dj_db_rotated_secret",
         ...
       ]
   ```

1. Declare a function to run when password auth fails:

   ```python
       DJ_DB_ROTATED_SECRET_FUNC = "path.to.function"
   ```

## Function Info

- The function takes no arguments.
- The function must return a dictionary with the keys `username` and `password`.

## Development

- Uses poetry

## Running Tests

Run psycopg2 and psycopg3 in isolation (like ci does):

1. Run `docker compose up`
1. Run `chmod +x run_tests.sh`
1. Run `./run_tests.sh`
justpub 0.1.2
Publish your python module to pypi with merely one command.

# Just-Pub
Shut up and just publish it!

Publish your python module to pypi with merely one command. 

## Install
```
pip install justpub
```

## Usage
path/to/where_your_package_are>
```
justpub <your-package-name> <your-pypi-api-token>
```

Then your package will be publish to pypi.org automatically, 

all configurations are configged with a meanless default value.

You can complete your package information anytime you want (or never 😈)!
fastapi-exception 1.3.10
FastAPI Exception
Requires Python: >=3.11

# FastAPI Exception

## Installation

```shell
pip install fastapi-exception
```

## How to use


### fastapi_exception exposes exceptions

- FastApiException
- ForbiddenException
- NotFoundException
- GoneException
- BadRequestException
- DirectResponseException
- EntityNotFoundException
- UnauthorizedException

### fastapi_exception exposes errors

- DuplicateError
- StringTooLongError
- StringTooShortError
- MissingError


### Configuration

```python
# config/exception.py
from config.i18n import i18n_service
from fastapi_exception import FastApiException

FastApiException.init()
FastApiException.init(translator_service=i18n_service) # pass translator_service if we integrate with i18n
```

### Use exceptions with throw_validation

```python
from fastapi_exception import throw_validation

throw_validation(type='value_error', loc=('body', 'key'))
```

### Use errors with throw_validation_with_exception

```python

from fastapi_exception import throw_validation_with_exception, MissingError

raise throw_validation_with_exception(MissingError(('body', 'product media or galleries')))
```

### Customize Exception

```python
from fastapi_exception import ValidationErrorDetail

class InvalidDataTypeError(ValidationErrorDetail):
  error_type = 'datatype.invalid'

  def __init__(
    self,
    loc: tuple[int | str, ...],
    ctx: dict[str, dict[str, Any]] | None = {},
    input: dict[str, Any] = {},
  ):
    super().__init__(self.error_type, loc, '', input, ctx)

throw_validation_with_exception(InvalidDataTypeError(('body', 'value')))
```
taskstodo 0.0.5
Manage Google Tasks from the command-line and sync tasks with other apps.
Requires Python: >=3.7

# taskstodo

taskstodo is a command-line application for managing Google Tasks, allowing you to view, create, update and delete task lists and their associated tasks. taskstodo can also perform a two-way sync between Google Tasks and [calcurse](https://calcurse.org/).

# Installation

```
pip install taskstodo
```

# Configuration

- Create new Google Cloud [project](https://console.cloud.google.com/projectcreate)
- Enable [Tasks API](https://console.cloud.google.com/apis/library/tasks.googleapis.com)
- Create new OAuth 2.0 client ID [credentials](https://console.cloud.google.com/apis/credentials)
- Download JSON file of credentials
- Copy file to `~/.config/taskstodo/credentials.json`
- Configure [OAuth consent screen](https://console.cloud.google.com/apis/credentials/consent) as an external user type

# Usage

Create task list:

```
taskstodo list -c <list_title>
```

Create task:

```
taskstodo task -c <task_title> [-n <note>] <list_title>
```

Show task lists:

```
taskstodo show-lists
```

Show tasks:

```
taskstodo list <list_title>
```

Update task list:

```
taskstodo list -u <new_title> -t <task_number> <list_title>
```

Update task:

```
taskstodo task -u <new_title> -t <task_number> <list_title>
```

Move task:

```
taskstodo task -m <new_position> -t <task_number> <list_title>
```

Delete task:

```
taskstodo task -d -t <task_number> <list_title>
```

Delete task list:

```
taskstodo list -d <list_title>
```

Sync calcurse and Google Tasks:

```
taskstodo sync-calcurse <list_title>
```

Show help:

```
taskstodo -h
```