semvec/pypi-packages huggingface dataset:
json-get 1.1.1
Get values from JSON objects using a path expression
License: MIT
Requires Python: >=3.5

Python JSON Get
===============

.. image:: https://img.shields.io/pypi/l/json-get.svg
   :target: https://pypi.python.org/pypi/json-get/
.. image:: https://img.shields.io/github/release/srittau/python-json-get/all.svg
   :target: https://github.com/srittau/python-json-get/releases/
.. image:: https://img.shields.io/pypi/v/json-get.svg
   :target: https://pypi.python.org/pypi/json-get/
.. image:: https://travis-ci.org/srittau/python-json-get.svg?branch=master
   :target: https://travis-ci.org/srittau/python-json-get

Get values from JSON objects usings a path expression. Optional type
checking is possible:

>>> from jsonget import json_get, json_get_default, JList
>>> j = {
...     "foo": {"num": 3.4, "s": "Text"},
...     "arr": [10, 20, 30],
... }
>>> json_get(j, "/foo/num")
3.4
>>> json_get(j, "/arr[1]")
20
>>> json_get(j, "/foo/unknown")
Traceback (most recent call last):
    ...
ValueError: JSON path '/foo/unknown' not found

Values are optionally checked against one of the following types:
``str``, ``int``, ``float``, ``bool``, ``list``, and ``dict``.
Checking for null values is not supported:

>>> json_get(j, "/foo/num", str)
Traceback (most recent call last):
    ...
TypeError: wrong JSON type str != float

``float`` will match any number, ``int`` will only match numbers without
a fractional part:

>>> json_get(j, "/foo/num", float)
3.4
>>> json_get(j, "/foo/num", int)
Traceback (most recent call last):
    ...
TypeError: wrong JSON type int != float

Additionally, the type of list values can be checked:

>>> json_get(j, "/arr", JList(int))
[10, 20, 30]

``json_get_default()`` can be used to return a default value if a given
path does not exist:

>>> json_get_default(j, "/bar", "default value")
'default value'
spot-memair 2018.5.28.0
updates memair with spot data
License: MIT
Keywords: spot memair location

===========
Spot Memair
===========

.. image:: https://badge.fury.io/py/spot-memair.svg
    :target: https://badge.fury.io/py/spot-memair

.. image:: http://img.shields.io/badge/license-MIT-yellow.svg?style=flat
    :target: https://github.com/gregology/spot-memair/blob/master/LICENSE

.. image:: https://img.shields.io/badge/contact-Gregology-blue.svg?style=flat
    :target: http://gregology.net/contact/

Overview
--------

Simple App to update Memair with Spot data

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

``spot-memair`` is available on PyPI

http://pypi.python.org/pypi/spot-memair

Install via ``pip``
::

    $ pip install spot-memair

Or via ``easy_install``
::

    $ easy_install spot-memair

Or directly from ``spot-memair``'s `git repo <https://github.com/gregology/spot-memair>`
::

    $ git clone git://github.com/gregology/spot-memair.git
    $ cd spot-memair
    $ python setup.py install

Basic usage
-----------
::

    $ python spot-memair -m <MEMAIR_ACCESS_TOKEN> -s <SPOT_API_TOKEN>
string-distance 1.0.0
Minimum Edit Distance
License: MIT
Requires Python: >=3.5

# Minimum Edit Distance in Cython

[<img src="https://travis-ci.com/blester125/string_distance.svg?branch=master" alt="Build Status">](https://travis-ci.com/blester125/string_distance)

This provides String Distance functions in Cython.

### Edit Based

With these metrics smaller is better.

 * `levenshtein` (1 for insert, 1 for delete, and 1 for substitution)
 * `levenshtein_no_sub` (1 for insert, 1 for delete, 2 for substitution)
 * `brew` (0.1 for insert, 15 for delete, and 1 for substitution)
 * `dameran_levenshtein` (1 for insert, 1 for delete, 1 for substitution, 1 for transposition)

### Token Based

 * `cosine_distance`
 * `binary_cosine_distance`
 * `jaccard_distance`

### Sequence Based

With these metrics Larger is better.

 * `longest_common_subsequence`
 * `longest_common_substring`
 * `Ratcliff-Obershelft`


### Extending and rolling your own cost functions

There are 2 kinds of functions used to define costs for the dynamic programming minimum edit distance algorithm. The first is `ctypedef int (*cmp_func)(int c1, int c2)` which is used to compare two characters and return a cost. The second is `ctypedef int (*char_func)(int c1, int c2)`. By implementing your own versions of these functions (I would recommned doing it in cost.pxd and inline'ing the function) you can pass them to the distance solver to implement your own weighting scheme. The `cmp_func` can be used to weight a substitution (for example a low cost to letter next to each other on the keyboard like `w` and `e` and high cost to far keys like `z` and `p`). The `char_func` can can be used to weight the insert or delete, for example you could weight inserts by their scabble scores.