semvec/pypi-packages huggingface dataset:
county-adjacency 0.1.3
This package provides adjacency information for US counties (or their equivalent).
License: MIT
Requires Python: >=3.6
Keywords: geography,geo,counties,us

County Adjacency
================

.. image:: https://github.com/chaddotson/county_adjacency/workflows/main/badge.svg
    :target: https://github.com/chaddotson/county_adjacency/actions?query=workflow%3Amain

.. image:: https://img.shields.io/pypi/v/county-adjacency.svg
    :target: https://pypi.org/project/county-adjacency/

.. image:: https://img.shields.io/pypi/pyversions/county-adjacency.svg
    :target: https://pypi.org/project/county-adjacency/

.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
    :target: https://github.com/psf/black

This package provides adjacency information for US counties (or their equivalent). This data is derived
from the US Census `website`.

.. _website: https://www.census.gov/geographies/reference-files/2010/geo/county-adjacency.html

Example
-------
.. code-block:: python

    from county_adjacency import get_neighboring_areas, CountyNotFoundError, supported_areas

    try:
        print(get_neighboring_areas("San Francisco County, CA"))
    except CountyNotFoundError as error:
        print(error)

    ('Contra Costa County, CA', 'Marin County, CA', 'San Mateo County, CA')


    supported_areas()

    ('Autauga County, AL', 'Baldwin County, AL', ... , 'St. John Island, VI', 'St. Thomas Island, VI')
speedtest-bot 1.0.1
Run Speedtest by Ookla programmatically
License: MIT
Requires Python: >=3.7
Keywords: python playwright web automation headless speedtest bot

# Speedtest Bot

<!-- [START badges] -->
[![pypi](https://img.shields.io/pypi/v/speedtest-bot)](https://pypi.org/project/speedtest-bot)
[![pyversions](https://img.shields.io/pypi/pyversions/speedtest-bot)](#)
[![license](https://img.shields.io/github/license/george-lim/speedtest-bot)](https://github.com/george-lim/speedtest-bot/blob/master/LICENSE)
<!-- [END badges] -->

> Speedtest Bot is a Python library that allows Speedtest by Ookla to be run programmatically. All communication is handled through the [Playwright API](https://microsoft.github.io/playwright-python).

<!-- [START getstarted] -->
## Getting Started

### Installation

To use Speedtest Bot in your project, add `speedtest-bot` to your project's `requirements.txt`.

### Usage

An [example project](https://github.com/george-lim/speedtest-bot/blob/master/examples/run_test) is provided to demonstrate how Speedtest Bot can be used to run Speedtest by Ookla and print the result URL.

Execute script on the command line:
```bash
cd examples/run_test
python3 -m pip install -r requirements.txt
python3 -m playwright install
python3 .
```
<!-- [END getstarted] -->
pert-estimator 0.1.2
PERT estimation tool
License: MIT
Keywords: pert,estimator,ticket,story

# Pert Estimator
PERT estimation tool

## Overview

*__NOTE__: The descriptions of the numbers and calculations provided in this section (and frankly the idea for this project) were taken from [The Clean Coder](https://www.amazon.com/Clean-Coder-Conduct-Professional-Programmers/dp/0137081073) by Robert C. Martin*

PERT is an estimating technique which uses three numbers to compute a final estimation (expected duration) and a standard deviation. The three numbers you provide are

- __O__: Optimistic Estimate. This number is wildly optimistic. You could only get the task done this quickly if absolutely everything went right. Indeed, in order for the math to work this number should have much less than a 1% change of occurrence.
- __N__: Nominal Estimate. This is the estimate with the greatest chance of success.
- __P__: Pessimistic Estimate. Once again this is wildly pessimistic. It should include everything except hurricanes, nuclear war, stray black holes, and other catastrophes. Again, the math only works if this number has much less than a 1% change of success.

### Calculations

Expected Duration:

    (O + 4N + P) / 6

_This gives you the final estimation for the task given the 3 estimates provided._

Standard Deviation:

    (P - O) / 6

_This gives you a measure of how uncertain the expected duration is. When this number is large, the uncertainty is large too._

## Usage

From the command line:

    $ pert_estimator
    Task name: test
    Optimistic estimate: .5
    Nominal estimate: 2
    Pessimistic estimate: 6
    Add task? (Y/N): n

    +------+------------+---------+-------------+-------------------+--------------------+
    | Task | Optimistic | Nominal | Pessimistic | Expected Duration | Standard Deviation |
    +------+------------+---------+-------------+-------------------+--------------------+
    | test |    0.5     |    2    |      6      |        2.4        |        0.9         |
    +------+------------+---------+-------------+-------------------+--------------------+
ctwrap 0.3.3
Python wrapper for batch simulations
License: MIT
Requires Python: >=3.6
Keywords: python,wrapper,cantera

![ci](https://github.com/microcombustion/ctwrap/workflows/CI/badge.svg)
![tag](https://img.shields.io/github/v/tag/microcombustion/ctwrap)
![PyPI](https://img.shields.io/pypi/v/ctwrap?color=lightblue)

# ctwrap

Python wrapper for batch simulations (e.g. Cantera).

## Documentation

[Sphinx documentation](https://microcombustion.github.io/ctwrap/) includes:

* A brief summary (see [Overview](https://microcombustion.github.io/ctwrap/overview.html)),
* Typical batch simulation descriptions (see [Batch Jobs](https://microcombustion.github.io/ctwrap/pages/batch.html)), and
* [Jupyter Notebooks](https://microcombustion.github.io/ctwrap/examples/jupyter.html) with illustrated examples.

## Philosophy

The software was developed with the following objectives in mind. It should:

* provide a low-level interface to essential [`cantera`](https://cantera.org/)
  capabilities
* create a flexible framework for generic simulations
* provide a command line interface
* be easily scriptable (using YAML configuration files)
* enforce units (via [`pint`](https://pint.readthedocs.io/en/stable/))
* enable parallel execution of (single-threaded) simulations (via
  [`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html))
* enable simple re-import of simulation results into native Cantera objects

> Although core functions of this software are continuously tested, there
  may be remaining bugs, non-working features, or other issues that could prevent a user from using this software to their specification. If you find problems, please report them in the issue tracker.

## Installation

The simplest approach is to install `ctwrap` via `pip`, i.e.

```
$ pip install ctwrap
```

> Note that `ctwrap` itself does not depend on a Cantera installation (only
  simulation modules do). It is recommended to install Cantera before ctwrap in a separate step.

## Example

A parallel batch job for adiabatic flame calculations uses the `freeflame` module (modified from Cantera's `adiabatic_flame.py` example). Based on the YAML configuration given as a reference, a variation of 12 equivalence ratio values is run as:

```
$ ctwrap run freeflame freeflame.yaml --parallel
```

Results are written to a single file `freeflame.h5`.