semvec/pypi-packages huggingface dataset:
popupfaucet 0.1.0b7
Ethereum testnet faucet CLI
Requires Python: >=3.8

# popupfaucet

Ethereum testnet faucet CLI

### What

Ephemeral faucets with shareable code phrases via an easy-to-use CLI app.

Network support for: OP Sepolia, Base Sepolia, Sepolia.

### Why

Motivation originated with wanting a pain-free way to get workshop participants some testnet ether to participate with interactive components of the workshop.

Current options leave something to be desired:

1. Ask users to navigate to and use a 3rd-party faucet
    - cons: external point of failure, sales pitches, hoops (account creation/PoW), exhausted daily limits
2. Create and pre-seed wallets then distribute, e.g., print and hand out
    - cons: physical/in-person only, manual process
3. Collect addresses, then use a script to distribute eth
    - cons: if manual, interruptions with latecomers; if automated, one more thing to run and maintain

`popupfaucet` introduces one more option: pre-seeding a faucet accessible to anyone that can install a Python package and is aware of your code phrase.

### How

1. `pipx install popupfaucet`
1. `popupfaucet create`
    1. Select a network
    1. Choose a unique "event code"
    1. Send testnet ether to the address provided
    1. ✨ voila ✨
1. `popupfaucet status` to view available funds in your faucet
1. `popupfaucet drip` to receive testnet funds from a faucet
    1. Select the network
    1. Enter the event code
    1. Enter the address to receive the testnet ether
    1. ✨ enjoy ✨

### Where

- This repo is the CLI app [deployed](https://pypi.org/project/popupfaucet) to PyPI
- Ape project with Solidity contract: [repo](https://github.com/wolovim/popupfaucet-contract)
- Server Flask app: [repo](https://github.com/wolovim/popupfaucet-server)
python-selenium-google-form 0.7.2
Automate Google Forms

# Introduction

The Python Selenium Google Form package is used to automate the completion of Google Forms. This package uses the Google Chrome browser.

<table>
  <tr>
    <th><strong>GitHub:</strong></th>
    <td><a href="https://github.com/bot-anica/python_selenium_google_form">https://github.com/bot-anica/python_selenium_google_form</a></td>
  </tr>
  <tr>
    <th><strong>PyPI:</strong></th>
    <td><a href="https://pypi.org/project/python-selenium-google-form/">https://pypi.org/project/python-selenium-google-form/</a></td>
  </tr>
</table>

## Installing

If you have pip on your system, you can simply install or upgrade the Python bindings:

```bash
    pip install python-selenium-google-form
```

Alternately, you can download the source distribution from PyPI <https://pypi.org/project/python-selenium-google-form/#files>, unarchive it, and run:

```bash
    python setup.py install
```

## Using

To use this package you should create Selenium driver and navigate to target Google Form. You can do it like me. I have 2 useful functions to simplify it:

```python
import undetected_chromedriver as uc

def get_driver(options: list) -> uc.Chrome:
    """
    Creating driver with settings
    :param options: uc.ChromeOptions
    :return: uc.Chrome
    """

    if options:
        driver_options: uc.ChromeOptions = uc.ChromeOptions()

        for option in options:
            driver_options.add_argument(option)

        return uc.Chrome(options=driver_options)

    else:
        return uc.Chrome()


def get_page(url: str, driver: uc.Chrome) -> None:
    """
    Loading page
    :param url: str
    :param driver: uc.Chrome
    :return: None
    """

    driver.get(url)
```

Using these functions and current package you can automate the completion of Google Forms. For example:

```python
from time import sleep
from typing import List

from python_selenium_google_form import process_form_fields_with_hotkeys, FieldConfig, FieldType

from selenium_methods import get_driver, get_page

WEB_DRIVER_OPTIONS = ["--start-maximized", "--disable-popup-blocking"]


def main() -> None:
    driver = get_driver(WEB_DRIVER_OPTIONS)
    driver.implicitly_wait(10)

    get_page(
        "https://docs.google.com/forms/d/e/1FAIpQLSfP0lcoj1XrdXtKCSwSkCaPEgGaGkY267U6yLCH3WkIz-58vg/viewform",
        driver)

    fields_list: List[FieldConfig] = [
        FieldConfig("first_name", FieldType.TEXT, "John"),
        FieldConfig("last_name", FieldType.TEXT, "Doe"),
        FieldConfig("job_title", FieldType.TEXT, "Software Developer"),
        FieldConfig("education_level", FieldType.RADIO, [1, 0, 0]),  # 1 means that field is selected, 0 - not selected
        FieldConfig("favourite_subjects", FieldType.CHECKBOX, [0, 0, 1, 1, 0]),  # 1 means that field is selected, 0 - not selected
        FieldConfig("experience", FieldType.SELECT, [0, 0, 1, 0]),  # 1 means that field is selected, 0 - not selected
        FieldConfig("date", FieldType.DATE, "01-09-2022"),
    ]

    process_form_fields_with_hotkeys(fields_list, driver)

    sleep(10)


main()
```
drone-troopers 0.0.2
A module for drone data processing
Requires Python: >=3.6

# Drone Troopers

`drone_troopers` is a Python module designed to classify CSV and Excel files and generate comprehensive reports. This tool is ideal for data analysts and developers who need to process and analyze tabular data efficiently.

## Features

- **Classify Data**: Automatically classify data in CSV and Excel files based on predefined criteria.
- **Generate Reports**: Produce detailed reports summarizing the classification results.
- **Support for Multiple Formats**: Handle both CSV and Excel file formats seamlessly.

## Installation

You can install the `drone_troopers` module using pip:

```bash
pip install drone_troopers
jsj 0.3.4
JavaScript QoL for JSON in python
Requires Python: >=3.12

# JSJ
JavaScript QoL for JSON in python.
## Motivation
Being familiar with Python and with JavaScript, there was something that I just couldn't get over with JavaScript that python just doesn't have, dot notation for json. This library seeks to solve python json issues in a variety of domains.
## Basic Usage
```python
from jsj import *

url = "https://api.weather.gov/points/39.7632,-101.6483"

data = fetch(url) \
    .json() \
    .get_data()

assert data.properties.timeZone == "America/Chicago"
```

## Requesting and flattening JSON
JSJ can flatten JSON documents, just like the `pandas.normalize_json()` function.
```python
from jsj import *
# Some sample data
data = JSON([
    {
        "id": 1,
        "name": "Cole Volk",
        "fitness": {"height": 130, "weight": 60},
    },
    {"name": "Mark Reg", "fitness": {"height": 130, "weight": 60}},
    {
        "id": 2,
        "name": "Faye Raker",
        "fitness": {"height": 130, "weight": 60},
    },
])

data_flattened, keys = data.flatten()

assert data_flattened[0] == {
    "id": 1,
    "name": "Cole Volk",
    "fitness_height": 130,
    "fitness_weight": 60,
}
```

## Getting the albums released by an artist
```python
# Sets the URLs `artist` parameter to Post Malone
url = "https://musicbrainz.org/ws/2/release?artist=b1e26560-60e5-4236-bbdb-9aa5a8d5ee19&type=album|ep&fmt=json"
# Fetches, flattens and gets the titles to all releases
albums = fetch(url) \
    .json() \
    .then(lambda data: data.flatten(base=["releases"])[0]) \
    .then(lambda data: [item.title for item in data]) \
    .get_data()

assert {"Stoney", "Hollywood’s Bleeding", "beerbongs & bentleys"}.issubset(albums)
```

## Installation
This package is available on pip
```
pip install jsj
```