semvec/pypi-packages huggingface dataset:
gsclight 0.0.1
A simplified package for Google Search Console API
Requires Python: >=3.6

A simplified, object-oriented helper library for the [Google Search Console API](https://developers.google.com/webmaster-tools/search-console-api-original). This package only covers basic API calls and was mainly created for practice purposes. To get the full Google Search Console API experience see Josh Carty's [python wrapper](https://github.com/joshcarty/google-searchconsole).


## Getting Started

Install the library on your local machine.

```bash
pip3 install gsclight
```

Use a Google account to create application credentials, download the JSON file and put it in the same directory as your script with the name `client_secret.json`. Every execution of any API-dependent library code,will prompt to perform the auth flow.

```python
from gsclight import oauth

CLIENT_SECRET = "../client_secret.json"
AUTH_SCOPE = "https://www.googleapis.com/auth/webmasters.readonly"
account = oauth.authenticate_to_gsc(CLIENT_SECRET, AUTH_SCOPE)
```

Use the Google Search Console wrapper to get an overview of all sites your personal account has access as well as all sites your account is verified for (meaning you can request data via the API).

```python
account.list_all_urls()
account.list_verified_urls()
```

To access data programmatically via the API specify the URI, date range as well as the dimensions your report should contain (metrics always consist of `clicks`, `impressions`, `ctr` and `position`). Filters are currently not implemented. The row limit is set to 25,000 rows and can not be adjusted. If you exceed the row limit try to request smaller chunks of data (e.g. apply smaller date range). Per default the search type `web` is used, but this can be adjusted to `image` or `video`.

```python
report, dimensions = account.get_data('https://www.my-website.com/', "2019-09-02", "2019-09-03", 'date', 'device')
```

In order to use the Google Search Console API response for further analysis the library comes with a built-in function to parse the reports to human-readable dataframes.

```python
from gsclight import parse_report as p
df = p.parse_report(report, dimensions)

df.head()
```

## Authentication & Client Secrets

This library currently only supports user-based OAuth crendentials. Service accounts can not be used.

The Google OAuth flows requires you to provide a [client id and secret](https://cloud.google.com/docs/authentication/end-user) in the from of a `JSON` file. You can create these in any Google Cloud or Google Developer project:

> 1. Open the [Google API Console Credentials](https://console.developers.google.com/apis/credentials) page.
> 2. Optional: From the project drop-down, choose Create a new project, enter a name for the project, and optionally, edit the provided Project ID. Click `Create`.
> 3. On the Credentials page, select `Create credentials`, then select `OAuth client ID`.
> 4. Select `Other` for the Application type, and enter any additional information required.
> 5. Click `Create`.
> 6. On the page that appears, you can download client id and secret as a JSON file.
sel2driver 0.0.1
It manages all browser driver automatically
Requires Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, <4
Keywords: sample setuptools development

# A sample Python project

A sample project that exists as an aid to the [Python Packaging User
Guide][packaging guide]'s [Tutorial on Packaging and Distributing
Projects][distribution tutorial].

This project does not aim to cover best practices for Python project
development as a whole. For example, it does not provide guidance or tool
recommendations for version control, documentation, or testing.

[The source for this project is available here][src].

Most of the configuration for a Python project is done in the `setup.py` file,
an example of which is included in this project. You should edit this file
accordingly to adapt this sample project to your needs.

----

This is the README file for the project.

The file should use UTF-8 encoding and can be written using
[reStructuredText][rst] or [markdown][md use] with the appropriate [key set][md
use]. It will be used to generate the project webpage on PyPI and will be
displayed as the project homepage on common code-hosting services, and should be
written for that purpose.

Typical contents for this file would include an overview of the project, basic
usage examples, etc. Generally, including the project changelog in here is not a
good idea, although a simple “What's New” section for the most recent version
may be appropriate.

[packaging guide]: https://packaging.python.org
[distribution tutorial]: https://packaging.python.org/tutorials/packaging-projects/
[src]: https://github.com/pypa/sampleproject
[rst]: http://docutils.sourceforge.net/rst.html
[md]: https://tools.ietf.org/html/rfc7764#section-3.5 "CommonMark variant"
[md use]: https://packaging.python.org/specifications/core-metadata/#description-content-type-optional
deep-geometry 2.0.0
A python library for preprocessing geospatial vector geometries for use in deep learning
Requires Python: >=3.6

# deep-geometry
A python library for preprocessing geospatial vector geometries for use in deep learning

## Rationale
Deep learning can use geospatial vector polygons directly (rather than a feature-extracted pre-processd version), but it requires vectorization and normalisation first, like any data source.

## Installation
`pip install deep-geometry`

## Usage
### Geometry vectorization
Make a numerical vector from a geometry: 
```
>>> from deep_geometry import vectorizer as gv

>>> geoms = [
...     'POINT(0 0)',
...     'POINT(1 1)',
...     'POINT(2 2)',
...     'POINT(3 3)',
...     'POINT(4 4)',
...     'POINT(5 5)',
...     'POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))',
... ]

>>> gv.vectorize_wkt(geoms[0])
array([[ 0.,  0.,  0.,  0.,  0.,  0.,  1.]])

>>> gv.vectorize_wkt(geoms[6])
array([[ 0.,  0.,  0., 1., 1.,  0.,  0.],
       [ 1.,  0.,  0., 1., 1.,  0.,  0.],
       [ 1.,  1.,  0., 1., 1.,  0.,  0.],
       [ 0.,  1.,  0., 1., 1.,  0.,  0.],
       [ 0.,  0.,  0., 1., 0.,  0.,  1.]])
```

Collect the max length from a set of geometries:
```
>>> max_len = gv.get_max_points(geoms)
>>> print('Maximum geometry node size in set:', max_len)
Maximum geometry node size in set: 7
```

### Numerical data normalization
Geometries regularly are in some kind of earth projection that is far from the origin of the coordinate system. In order for machine learning models to learn, data needs to be normalized. A usual way to go about this is to mean-center the instances and to divide by the dataset standard deviation.

The library provides a convenience class for normalization, modeled after the scalers from [scikit-learn](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html) with a .fit() and a .transform() method:

```
>>> from deep_geometry import GeomScaler
>>> import numpy
>>> gs = GeomScaler()  # simply initialize
>>> geom6 = gv.vectorize_wkt(geoms[6])
>>> dataset = numpy.repeat([geom6], 4, axis=0)
>>> gs.fit(dataset)
>>> gs.scale_factor
0.5
>>> normalized_data = gs.transform(dataset)
>>> normalized_data[0]  # see: zero-mean and scaled to standard deviation
array([[-1., -1.,  0.,  1.,  1.,  0.,  0.],
       [ 1., -1.,  0.,  1.,  1.,  0.,  0.],
       [ 1.,  1.,  0.,  1.,  1.,  0.,  0.],
       [-1.,  1.,  0.,  1.,  1.,  0.,  0.],
       [-1., -1.,  0.,  1.,  0.,  0.,  1.]])

```
msg91-otp 0.1.0
Minimal OTP only API coverage for msg91.com service
Requires Python: >=2.7

### msg91-otp

[msg91.com](https://msg91.com) is one of the bulk SMS provider in India. This package `msg91-otp` is a python wrapper for **sending** and **verifying** OTPs using msg91.com. This is a minimal wrapper covers only OTP use-case and doesn't cover all HTTP API's exposed by msg91.

#### Install

    python setup.py install

#### Usage

    from msg91_otp.client import OTPClient

    # obtain this auth_key from msg91.com
    auth_key = "xxxxxxxxxxxxxxxxx"
    otp_client = OTPClient(auth_key)

    sender = "YOUR_SERVICE_NAME"
    # if OTP value is not supplied, msg91 automatically creates for you
    message = "Your One Time Password (OTP) is"
    receiver = "9876543210"
    service_response = otp_client.send_otp(receiver, sender=sender, message=message)

    # if you want to supply your own OTP
    otp = 3342
    service_response = otp_client.send_otp(receiver, otp=otp)

    print (service_response.status, service_response.message)

    # verify OTP for a given mobile number
    verify_response = otp_client.verify_otp(receiver, otp)
    print (verify_response.status, verify_response.message)

    # re-send a OTP
    otp_resend = otp_client.resend_otp(receiver)
    print (otp_resend.status, otp_resend.message)

    # Asynchronous client follows the same method signatures
    from msg91_otp.client import AsyncOTPClient
    async_client = AsyncOTPClient(auth_key)

    await async_client.send_otp(receiver)


#### Contributors

1. Prasanna Venkadesh

#### License

This package is licenced under GNU AGPL v3.0
jetconf 0.3.6
Pure Python implementation of the RESTCONF protocol
Keywords: restconf,yang,data model,configuration,json

*******
Jetconf
*******

Jetconf is an implementation of the RESTCONF_ protocol written in
Python 3.

* `Documentation`_
* `Git repository`_

Main features:

* HTTP/2 over TLS, certificate-based authentication of clients

* JSON data encoding

* Per-user candidate datastores with transactions

* Support for NACM_

Installation
============
Python 3.5 or newer is required::

    ~$ apt-get install python3
    ~$ apt-get install python3-pip

Jetconf can be installed by PyPI::

   $ python3 -m pip install jetconf

Run Jetconf
===========
::

    ~$ jetconf -c <path_to_config_file.yaml>

.. _RESTCONF: https://tools.ietf.org/html/draft-ietf-netconf-restconf-18
.. _NACM: https://datatracker.ietf.org/doc/rfc6536/
.. _Git repository: https://github.com/CZ-NIC/jetconf
.. _Documentation: https://jetconf.readthedocs.io