semvec/pypi-packages huggingface dataset:
bulltools 0.2
Hacking tools Auto-install script.

<!--
https://pypi.org/project/bulltools/
-->

[![](https://img.shields.io/pypi/pyversions/readme-generator.svg?longCache=True)](https://pypi.org/project/readme-generator/)

#### Installation
```bash
$ pip install bulltools
```

#### Features
+   **`bulltools`**, ** Hacking tools auto-install script**


#### How it works
```
$ pip install bulltools
$ bulltools
```

#### Usage
```
$ bulltools [-h|i|v|a|r]

options :-
-h : print help
-i : install
-v : version
-a : about us
-r : remove


Created by Parixit Sutariya
Github : github.com/Bhai4You
Blogspot : https://bhai4you.blogspot.com

```

<p align="center">
    <a href="https://github.com/Bhai4You">Github</a>
</p>
fyers-logger 0.1.7
Fyers Internal Logging Library
Requires Python: >=3.8

README
========

This module is installed via pip:

```
pip install fyers-logger
```

Packages Required
 - aws-lambda-powertools


Usage

```
from fyers_logger import FyersLogger

logger = FyersLogger("ServiceName", "DEBUG")
```

Additional parameters

```
import logging
logger = FyersLogger("ServiceName", "DEBUG", logger_handler=logging.FileHandler("filename.log"))
```


Set parameters for a request

```
import uuid

logger.set_fyId("ABC123")
logger.set_requestId(f"{uuid.uuid4()}")
```


Clear data after every request

```
logger.clear_data()
```

Since this is an extension of the aws-lambda-powertools logger, all parameters supported by aws-lambda-powertools logger are supported. Documentation can be found here: https://awslabs.github.io/aws-lambda-powertools-python/latest/core/logger/
microcosm-flask2 4.0.0
Flask-based webserver micro framework (Flask 2.x Fork)
Requires Python: >=3.6
Keywords: microcosm

# microcosm-flask

Opinionated Flask services.

[![Circle CI](https://circleci.com/gh/globality-corp/microcosm-flask/tree/develop.svg?style=svg)](https://circleci.com/gh/globality-corp/microcosm-flask/tree/develop)


## Conventions

 - Classify API endpoints according to an enumerated set of operations with well-defined naming conventions
 - Handle errors consistently using a top-level error and nested sub-errrors
 - Handle UUIDs as route path keys
 - Protect endpoints with basic auth
 - Use HAL JSON links to related resources to each other
 - Use Swagger to publish endpoints for interoperability
 - Automate generation of endpoints according to conventions:
    - A health check API endpoint exposes service health
    - RESTful endpoints provide CRUD operations on resources
    - RESTful endpoints allows one resource to be related to another
    - API discovery endpoints allow resource data to be discovered/spidered
    - Swagger endpoints allow endpoint integration to be automated

## Setup

Create a virtualenv

```
mkvirtualenv microcosm-flask
```

Install dependencies

```
pip install -U -e .
```

## Tests

Run the tests

```
python setup.py nosetests
```


## Configuration

 - The object graph's `debug` and `testing` flags are propagated to the Flask application
abeci 1.0.5
Find perfect pangrams

# abeci 

Create [perfect pangrams][pp], sentences with exactly one of each letter in the English alphabet.

[pp]: https://en.wikipedia.org/wiki/Pangram#Perfect_pangrams

## Generate Pangrams

After installing `abeci` as a package, you can run:

```
abeci-pangrams
```

This script makes a text file with this name, in `results` by default:

```
./results/std4_max1_has_2x_3x/pangrams_1024_0x1_128x2_512x3_1024x4.txt
```

If the `effects/source.p` file is missing,
  - The script uses Google's English Corpus of all books published in 2008.
  - The script will wiret an `effects/source.p` to speed up future calls to the script.

it also:
  - writes a log file such as `2022-04-07T0200.log`.
  - writes intermediate files in an `effects` directory.

The file is named after the current date and UTC time.

Run the help command for options: `abeci-pangrams -h`


## API Usage

- No programatic api is documented at this time:
- Look to `src/modules/savePangrams.py` for inspiration


# Local Installation

## Dependencies

Install [Miniconda](https://docs.conda.io/en/latest/miniconda.html) or Anaconda.

```
conda env create -f environment.yaml
```
or 
```
conda env update -f environment.yaml
```

Then, activate the installed environment:

```
conda activate abeci
```

After installing dependencies, you can run:

```
python src/pangrams.py
```

Run the help command for options: `python src/pangrams.py -h`

## Build Locally w/ pip

Upgrade pip and build with pip

```
python -m pip install --upgrade pip
pip install build
```

## Install Locally

Using the conda environment, install locally with pip:

```
VIRTUAL_ENV=$CONDA_PREFIX pip install --src $VIRTUAL_ENV/src -e .
```

<!---
## Build Locally w/ conda

Update setuptools in conda environemnt

```
python3 -m pip install --user --upgrade setuptools wheel 
```

Install conda-build

```
conda config --add channels conda-forge
```

```
conda install conda-build
```

```
conda build .
```
--->

## Test

After installing locally, run:

```
bash run_test.sh
```

## Publish

Publishing happens on release. The following two links were inspirations:

- [Publish to pip](https://levelup.gitconnected.com/turn-your-python-code-into-a-pip-package-in-minutes-433ae669657f)
- [Publish to conda](https://levelup.gitconnected.com/publishing-your-python-package-on-conda-and-conda-forge-309a405740cf)
frappysqlapibilling 0.1.0
SQL Store for the API Billing Backend

# Frappy Python SQL Store for API Billing

Python SQLAlchemy Store Implementation for Tracking [API Billing](https://github.com/ilfrich/frappy-api-billing) Usage.

## Usage

```python
from frappysqlapibilling import UsageStore
from frappyapibilling import ApiBilling
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

# create flask app
app = Flask(__name__)

# create SQL DB connection
sql_host, sql_port, sql_user, sql_pass, sql_db = ...
sql_connect_str = f"{sql_user}:{sql_pass}@{sql_host}:{sql_port}/{sql_db}"
# example for postgres
app.config["SQLALCHEMY_DATABASE_URI"] = f"postgresql+psycopg2://{sql_connect_str}"
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
# create db
sql_db = SQLAlchemy(app)

# create sql store
store = UsageStore(sql_db=sql_db, table_name="api_billing_usage")  # table name defaults to "api_billing_usage"

# pass the store instance to the api billing constructor
api_billing = ApiBilling(usage_store=store)
```

See [API Billing Usage](https://github.com/ilfrich/frappy-api-billing#usage) for details on how to use the module.
sortty 0.0.3
Simple combination of advanced sorters

# Sortty - simple combination of advanced sorters

The main benefit is the function ```get_multi_sorted```. It makes it easy to sort a sequence by several criteria at the
same time. All sorting parameters can always be set manually, but they can also be determined automatically.

Attention! For **simple sorting**, for example, from minimum to maximum sorter usage **will be redundant and slow**, for
such situations write 1 line of code using the standard library:) Or rewrite this method in MinSorter class...