semvec/pypi-packages huggingface dataset:
cheinsteinpy 0.1.5
A Python library to get information from Chegg.

# cheinstein.py

## A Python library to get information from Chegg.

> **Note**: We are not affiliated with chegg.com in any way.

Chegg is a great resource for many students around the world. Though since it is a paid resource, it is not accessible to everyone. With cheinstein.py, it parses the information from chegg.com, and makes it much easier to work with.

### Currently Supported

- Solutions
- Questions

## Installation

Install cheinstein.py using pip:

```shell
$ pip install cheinsteinpy
```
uwsgi-readiness-check 0.2.0
Readiness Check for uWSGI

# uwsgi-readiness-check

Readiness check for uwsgi using its stats socket

Use this check to mark a pod running `uwsgi` as `NotReady` whenever the uwsgi queue crosses a threshold.
This will allow uwsgi to finish processing requests in its queue before Kubernetes sends more traffic to it 

# Local Development / Testing

Because the readiness check needs to run as part of a pod, in order to have functional test we deploy
a small python+uwsgi application that sleeps for a few seconds + a second python "client" script that
makes requests. Since the application sleeps upon a request and new requests are constantly being sent,
uwsgi will eventually queue and we'll readiness checks should fail.

[Kind installation](https://kind.sigs.k8s.io/docs/user/quick-start/)
[Skaffold installation](https://skaffold.dev/docs/install/#standalone-binary)
[Kubectl installation](https://kubernetes.io/docs/tasks/tools/install-kubectl-linux/)

## Running locally

With `kind`, `kubectl` and `skaffold` installed, simply run:

```
skaffold dev
```

Skaffold builds a docker image, loads into the kind "cluster" and creates the Pods, watches for changes in
the filesystem and automatically re-deploys when needed.

# Examples:

The example below will prevent traffic from hitting the Pod once the queue reaches 70% its max capacity:

```
          readinessProbe:
            exec:
              command:
                - uwsgi-is-ready
                - --stats-socket
                - /tmp/uwsgi-stats
                - --queue-threshold
                - 0.7
            failureThreshold: 2
            initialDelaySeconds: 5
            periodSeconds: 5
            successThreshold: 1
            timeoutSeconds: 1
```

You can find a complete example in `k8s/deployment.yaml`

# Installation

In the container image used by your Pod, run:

```
pip install uwsgi-readiness-check
```
dor-utils 0.0.1
Some utils by Dor Miron

# Afori Utils

This package contains an aggregation of tools used by Dor Miron.
Afori is my cat, and he contributed some changes now and then.

## Installation

Run the following to install:

```python 
pip install afori_utils
```

## Usage
```python
from afori_utils import pyplot_utils
from afori_utils import sync_utils
from afori_utils import debug_utils
```

##### add usages (here what is the purpose)
here the actual code
simple-eartquake-info 0.1.0
This package will get the simple info of eartquake from BMKG
Requires Python: >=3.6, <4
Keywords: earthquake,earthquake info

# Simple Eartquake Information
This package will get the simple info of eartquake from BMKG

## HOW TO USE
```
import gempaterkini

if __name__ == "__main__":
    result = gempaterkini.ekstraksi_data()
    gempaterkini.tampilkan_data(result)
```

## HOW IT WORK?
This package will scrape from [BMKG](https://bmkg.go.id)

This package will use BeautifulSoap4 and Request to produce output in the form of JSON that is ready to be used in web or mobile application
kernaux 0.0.0
Bindings to libkernaux - auxiliary library for kernel development
Requires Python: >=3.8

kernaux
=======

[![Test](https://github.com/tailix/libkernaux/actions/workflows/test.yml/badge.svg)](https://github.com/tailix/libkernaux/actions/workflows/test.yml)

Bindings to **libkernaux** - auxiliary library for kernel development.
barbq 0.0.3
Python-native SQL dialect that renders to BigQuery
Requires Python: >=3.6

# barbq
Python-native SQL dialect that renders to BigQuery

Why: exposes SQL to the machinery of python

How:
    Data zone: encode the BQ CFG in typed membership-relations of python objects, write a reverse parser and reverse lexer, which can be chained to form a serializer for BQ ASTs

    UI zone: write overloaded/pass-through constructors using Union types to satisfy the looks-like-SQL constraint

What it looks like:
# TODO include code snippets

Tradeoffs left to the user:
    Your code can look like SQL; the more pythonic power you want, the more your code will look like python

    You can use the constructor-overloading to make your code look like SQL; the more type validation you want, the more your code will look like type-annotated SQL