reapxdev/pypi-scraper huggingface dataset:
geopy 2.5.0 — Python Geocoding Toolbox
License: MIT 
Keywords: geocode, geocoding, gis, geographical, maps, earth, distance
Requires Python: >=3.8
Dependencies: geographiclib<3,>=1.52, flake8<7.4,>=7.1.2; extra == "dev", isort<8.1,>=5.13.2; extra == "dev", coverage; extra == "dev", pytest-asyncio>=0.17; extra == "dev", pytest>=3.10; extra == "dev", sphinx<=9.1.0; extra == "dev", readme_renderer; extra == "dev", sphinx<=9.1.0; extra == "dev", sphinx-issues; extra == "dev", sphinx_rtd_theme>=3.1.0; extra == "dev", flake8<7.4,>=7.1.2; extra == "dev-lint", isort<8.1,>=5.13.2; extra == "dev-lint", coverage; extra == "dev-test", pytest-asyncio>=0.17; extra == "dev-test", pytest>=3.10; extra == "dev-test", sphinx<=9.1.0; extra == "dev-test", readme_renderer; extra == "dev-docs", sphinx<=9.1.0; extra == "dev-docs", sphinx-issues; extra == "dev-docs", sphinx_rtd_theme>=3.1.0; extra == "dev-docs", aiohttp; extra == "aiohttp", urllib3>=1.24.2; extra == "requests", requests>=2.16.2; extra == "requests", pytz; extra == "timezone"

geopy
=====

.. image:: https://img.shields.io/pypi/v/geopy.svg?style=flat-square
    :target: https://pypi.python.org/pypi/geopy/
    :alt: Latest Version

.. image:: https://img.shields.io/github/actions/workflow/status/geopy/geopy/ci.yml?branch=master&style=flat-square
    :target: https://github.com/geopy/geopy/actions/workflows/ci.yml?query=branch%3Amaster
    :alt: Build Status

.. image:: https://img.shields.io/github/license/geopy/geopy.svg?style=flat-square
    :target: https://pypi.python.org/pypi/geopy/
    :alt: License


geopy is a Python client for several popular geocoding web
services.

geopy makes it easy for Python developers to locate the coordinates of
addresses, cities, countries, and landmarks across the globe using
third-party geocoders and other data sources.

geopy includes geocoder classes for the `OpenStreetMap Nominatim`_,
`Google Geocoding API (V3)`_, and many other geocoding services.
The full list is available on the `Geocoders doc section`_.
Geocoder classes are located in `geopy.geocoders`_.

.. _OpenStreetMap Nominatim: https://nominatim.org
.. _Google Geocoding API (V3): https://developers.google.com/maps/documentation/geocoding/
.. _Geocoders doc section: https://geopy.readthedocs.io/en/latest/#geocoders
.. _geopy.geocoders: https://github.com/geopy/geopy/tree/master/geopy/geocoders

geopy is tested against CPython (versions 3.8 to 3.15)
and PyPy3. The geopy 1.x line also supported CPython 2.7, 3.4, and PyPy2.

© geopy contributors 2006-2026 (see AUTHORS) under the `MIT
License <https://github.com/geopy/geopy/blob/master/LICENSE>`__.

Installation
------------

Install using `pip <http://www.pip-installer.org/en/latest/>`__ with:

::

    pip install geopy

Or, `download a wheel or source archive from
PyPI <https://pypi.python.org/pypi/geopy>`__.

Geocoding
---------

To geolocate a query to an address and coordinates:

.. code:: pycon

    >>> from geopy.geocoders import Nominatim
    >>> geolocator = Nominatim(user_agent="specif
et-xmlfile 2.0.0 — An implementation of lxml.xmlfile for the standard library
Author: See AUTHORS.txt
License: MIT 
Requires Python: >=3.8

.. image:: https://foss.heptapod.net/openpyxl/et_xmlfile/badges/branch/default/coverage.svg
    :target: https://coveralls.io/bitbucket/openpyxl/et_xmlfile?branch=default
    :alt: coverage status

et_xmfile
=========

XML can use lots of memory, and et_xmlfile is a low memory library for creating large XML files
And, although the standard library already includes an incremental parser, `iterparse` it has no equivalent when writing XML. Once an element has been added to the tree, it is written to
the file or stream and the memory is then cleared.

This module is based upon the `xmlfile module from lxml <http://lxml.de/api.html#incremental-xml-generation>`_ with the aim of allowing code to be developed that will work with both libraries.
It was developed initially for the openpyxl project, but is now a standalone module.

The code was written by Elias Rabel as part of the `Python Düsseldorf <http://pyddf.de>`_ openpyxl sprint in September 2014.

Proper support for incremental writing was provided by Daniel Hillier in 2024

Note on performance
-------------------

The code was not developed with performance in mind, but turned out to be faster than the existing SAX-based implementation but is generally slower than lxml's xmlfile.
There is one area where an optimisation for lxml may negatively affect the performance of et_xmfile and that is when using the `.element()` method on the xmlfile context manager. It is, therefore, recommended simply to create Elements write these directly, as in the sample code.
executing 2.2.1 — Get the currently executing AST node of a frame, and other information
Author: Alex Hall
License: MIT 
Requires Python: >=3.8
Dependencies: asttokens>=2.1.0; extra == "tests", ipython; extra == "tests", pytest; extra == "tests", coverage; extra == "tests", coverage-enable-subprocess; extra == "tests", littleutils; extra == "tests", rich; python_version >= "3.11" and extra == "tests"

# executing

[![Build Status](https://github.com/alexmojaki/executing/workflows/Tests/badge.svg?branch=master)](https://github.com/alexmojaki/executing/actions) [![Coverage Status](https://coveralls.io/repos/github/alexmojaki/executing/badge.svg?branch=master)](https://coveralls.io/github/alexmojaki/executing?branch=master) [![Supports Python versions 3.5+, including PyPy](https://img.shields.io/pypi/pyversions/executing.svg)](https://pypi.python.org/pypi/executing)

This mini-package lets you get information about what a frame is currently doing, particularly the AST node being executed.

* [Usage](#usage)
    * [Getting the AST node](#getting-the-ast-node)
    * [Getting the source code of the node](#getting-the-source-code-of-the-node)
    * [Getting the `__qualname__` of the current function](#getting-the-__qualname__-of-the-current-function)
    * [The Source class](#the-source-class)
* [Installation](#installation)
* [How does it work?](#how-does-it-work)
* [Is it reliable?](#is-it-reliable)
* [Which nodes can it identify?](#which-nodes-can-it-identify)
* [Projects that use this](#projects-that-use-this)

## Usage

### Getting the AST node

```python
import executing

node = executing.Source.executing(frame).node
```

Then `node` will be an AST node (from the `ast` standard library module) or None if the node couldn't be identified (which may happen often and should always be checked).

`node` will always be the same instance for multiple calls with frames at the same point of execution.

If you have a traceback object, pass it directly to `Source.executing()` rather than the `tb_frame` attribute to get the correct node.

### Getting the source code of the node

For this you will need to separately install the [`asttokens`](https://github.com/gristlabs/asttokens) library, then obtain an `ASTTokens` object:

```python
executing.Source.executing(frame).source.asttokens()
```

or:

```python
executing.Source.for_frame(frame).asttokens()
```

or use one of the con
eventlet 0.41.1 — Highly concurrent networking library
License: MIT 
Requires Python: >=3.10
Dependencies: dnspython>=1.15.0, greenlet<3.4, black; extra == "dev", build; extra == "dev", commitizen; extra == "dev", isort; extra == "dev", pip-tools; extra == "dev", pre-commit; extra == "dev", twine; extra == "dev"

Warning
=======

**New usages of eventlet are now heavily discouraged! Please read the
following.**

Eventlet was created almost 18 years ago, at a time where async
features were absent from the CPython stdlib. With time eventlet evolved and
CPython too, but since several years the maintenance activity of eventlet
decreased leading to a growing gap between eventlet and the CPython
implementation.

This gap is now too high and can lead you to unexpected side effects and bugs
in your applications.

Eventlet now follows a new maintenance policy. **Only maintenance for
stability and bug fixing** will be provided. **No new features will be
accepted**, except those related to the asyncio migration. **Usages in new
projects are discouraged**. **Our goal is to plan the retirement of eventlet**
and to give you ways to move away from eventlet.

If you are looking for a library to manage async network programming,
and if you do not yet use eventlet, then, we encourage you to use `asyncio`_,
which is the official async library of the CPython stdlib.

If you already use eventlet, we hope to enable migration to asyncio for some use
cases; see `Migrating off of Eventlet`_. Only new features related to the migration
solution will be accepted.

If you have questions concerning maintenance goals or concerning
the migration do not hesitate to `open a new issue`_, we will be happy to
answer them.

.. _asyncio: https://docs.python.org/3/library/asyncio.html
.. _open a new issue: https://github.com/eventlet/eventlet/issues/new
.. _Migrating off of Eventlet: https://eventlet.readthedocs.io/en/latest/asyncio/migration.html#migration-guide

Eventlet
========

.. image:: https://img.shields.io/pypi/v/eventlet
    :target: https://pypi.org/project/eventlet/

.. image:: https://img.shields.io/github/actions/workflow/status/eventlet/eventlet/test.yaml?branch=master
    :target: https://github.com/eventlet/eventlet/actions?query=workflow%3Atest+branch%3Amaster

.. image:: https://codecov.io/gh/e
envparse 0.2.0 — Simple environment variable parsing
Author: Rick Harris
License: MIT 

envparse
========
``envparse`` is a simple utility to parse environment variables.

If you use Heroku and/or subscribe to the tenets of the
`12 Factor App <http://www.12factor.net/>`_
you'll be using a lot of environment variable-based configuration in your app.
``os.environ`` is a great choice to start off with but over time you'll find
yourself duplicating quite a bit of code around handling raw environment
variables.

``envparse`` aims to eliminate this duplicated, often inconsistent parsing
code and instead provide a single, easy-to-use wrapper.

Ideas, and code portions, have been taken from `django-environ
<https://github.com/joke2k/django-environ>`_ project but made framework
agnostic.


Installing
----------
Through PyPI::

    $ pip install envparse

Manually::

    $ pip install git+https://github.com/rconradharris/envparse.git
    OR
    $ git clone https://github.com/rconradharris/envparse && cd envparse
    $ python setup.py install


Usage
-----
In your settings or configuration module, first either import the standard
parser or one with a schema::

    # Standard
    from envparse import env

    # Schema
    from envparse import Env
    env = Env(BOOLEAN_VAR=bool, LIST_VAR=dict(type=list, subtype=int))


``env`` can then be called in two ways:

* Type explicit: ``env('ENV_VAR_NAME', type=TYPE, ...)``
* Type implicit (for Python builtin types only): ``env.TYPE('ENV_VAR_NAME', ...)``
If type is not specified, explicitly or implicitly, then the default
type is ``str``.


Casting to a specified type::

    # Environment variable: MAIL_ENABLED=1

    mail_enabled = env('MAIL_ENABLED', type=bool)
    # OR mail_enabled = env.bool('MAIL_ENABLED')
    assert mail_enabled is True

Casting nested types::

    # Environment variable: FOO=1,2,3
    foo = env('FOO'), subtype=int)
    # OR: foo = env('FOO', type=list, subtype=int)
    # Note that there is no way to implicitly call subtypes.
    assert foo == [1, 2, 3]

Specifying defaults::

    # Environment varia