polyfuzz


Namepolyfuzz JSON
Version 0.4.2 PyPI version JSON
download
home_pagehttps://github.com/MaartenGr/PolyFuzz
SummaryPolyFuzz performs fuzzy string matching, grouping, and evaluation.
upload_time2023-09-03 07:51:57
maintainer
docs_urlNone
authorMaarten Grootendorst
requires_python>=3.6
license
keywords nlp string matching embeddings levenshtein tfidf bert
VCS
bugtrack_url
requirements No requirements were recorded.
Travis-CI No Travis.
coveralls test coverage No coveralls.
            <img src="images/logo.png" width="70%" height="70%"/>

[![PyPI - Python](https://img.shields.io/badge/python-3.6%20|%203.7%20|%203.8-blue.svg)](https://pypi.org/project/keybert/)
[![PyPI - License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/MaartenGr/keybert/blob/master/LICENSE)
[![PyPI - PyPi](https://img.shields.io/pypi/v/polyfuzz)](https://pypi.org/project/polyfuzz/)
[![Build](https://img.shields.io/github/workflow/status/MaartenGr/polyfuzz/Code%20Checks/master)](https://pypi.org/project/polyfuzz/)
[![docs](https://img.shields.io/badge/docs-Passing-green.svg)](https://maartengr.github.io/PolyFuzz/)  
**`PolyFuzz`** performs fuzzy string matching, string grouping, and contains extensive evaluation functions. 
PolyFuzz is meant to bring fuzzy string matching techniques together within a single framework.

Currently, methods include a variety of edit distance measures, a character-based n-gram TF-IDF, word embedding
techniques such as FastText and GloVe, and 🤗 transformers embeddings.  

Corresponding medium post can be found [here](https://towardsdatascience.com/string-matching-with-bert-tf-idf-and-more-274bb3a95136?source=friends_link&sk=0f765b76ceaba49363829c13dfdc9d98).


<a name="installation"/></a>
## Installation
You can install **`PolyFuzz`** via pip:
 
```bash
pip install polyfuzz
```

You may want to install more depending on the transformers and language backends that you will be using. The possible installations are:

```python
pip install polyfuzz[sbert]
pip install polyfuzz[flair]
pip install polyfuzz[gensim]
pip install polyfuzz[spacy]
pip install polyfuzz[use]
```

If you want to speed up the cosine similarity comparison and decrease memory usage when using embedding models, 
you can use `sparse_dot_topn` which is installed via:

```bash
pip install polyfuzz[fast]
```

<details>
<summary>Installation Issues</summary>

You might run into installation issues with `sparse_dot_topn`. If so, one solution that has worked for many 
is by installing it via conda first before installing PolyFuzz:

```bash
conda install -c conda-forge sparse_dot_topn
```

If that does not work, I would advise you to look through their 
issues](https://github.com/ing-bank/sparse_dot_topn/issues) page or continue to use PolyFuzz without `sparse_dot_topn`. 

</details>  


<a name="gettingstarted"/></a>
## Getting Started

For an in-depth overview of the possibilities of `PolyFuzz` 
you can check the full documentation [here](https://maartengr.github.io/PolyFuzz/) or you can follow along 
with the notebook [here](https://github.com/MaartenGr/PolyFuzz/blob/master/notebooks/Overview.ipynb).

### Quick Start

The main goal of `PolyFuzz` is to allow the user to perform different methods for matching strings. 
We start by defining two lists, one to map from and one to map to. We are going to be using `TF-IDF` to create 
n-grams on a character level in order to compare similarity between strings. Then, we calculate the similarity 
between strings by calculating the cosine similarity between vector representations. 

We only have to instantiate `PolyFuzz` with `TF-IDF` and match the lists:

```python
from polyfuzz import PolyFuzz

from_list = ["apple", "apples", "appl", "recal", "house", "similarity"]
to_list = ["apple", "apples", "mouse"]

model = PolyFuzz("TF-IDF")
model.match(from_list, to_list)
```  

The resulting matches can be accessed through `model.get_matches()`:

```python
>>> model.get_matches()
         From      To    Similarity
0       apple   apple    1.000000
1      apples  apples    1.000000
2        appl   apple    0.783751
3       recal    None    0.000000
4       house   mouse    0.587927
5  similarity    None    0.000000

``` 

**NOTE 1**: If you want to compare distances within a single list, you can simply pass that list as such: `model.match(from_list)`

**NOTE 2**: When instantiating `PolyFuzz` we also could have used "EditDistance" or "Embeddings" to quickly 
access Levenshtein and FastText (English) respectively. 

### Production
The `.match` function allows you to quickly extract similar strings. However, after selecting the right models to be used, you may want to use PolyFuzz 
in production to match incoming strings. To do so, we can make use of the familiar `fit`, `transform`, and `fit_transform` functions. 

Let's say that we have a list of words that we know to be correct called `train_words`. We want to any incoming word to mapped to one of the words in `train_words`. 
In other words, we `fit` on `train_words` and we use `transform` on any incoming words:

```python
from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import CountVectorizer
from polyfuzz import PolyFuzz

train_words = ["apple", "apples", "appl", "recal", "house", "similarity"]
unseen_words = ["apple", "apples", "mouse"]

# Fit
model = PolyFuzz("TF-IDF")
model.fit(train_words)

# Transform
results = model.transform(unseen_words)
```

In the above example, we are using `fit` on `train_words` to calculate the TF-IDF representation of those words which are saved to be used again in `transform`. 
This speeds up `transform` quite a bit since all TF-IDF representations are stored when applying `fit`. 

Then, we apply save and load the model as follows to be used in production:

```python
# Save the model
model.save("my_model")

# Load the model
loaded_model = PolyFuzz.load("my_model")
```

### Group Matches
We can group the matches `To` as there might be significant overlap in strings in our to_list. 
To do this, we calculate the similarity within strings in to_list and use `single linkage` to then 
group the strings with a high similarity.

When we extract the new matches, we can see an additional column `Group` in which all the `To` matches were grouped to:

```python
>>> model.group(link_min_similarity=0.75)
>>> model.get_matches()
	      From	To		Similarity	Group
0	     apple	apple	1.000000	apples
1	    apples	apples	1.000000	apples
2	      appl	apple	0.783751	apples
3	     recal	None	0.000000	None
4	     house	mouse	0.587927	mouse
5	similarity	None	0.000000	None
```

As can be seen above, we grouped apple and apples together to `apple` such that when a string is mapped to `apple` it 
will fall in the cluster of `[apples, apple]` and will be mapped to the first instance in the cluster which is `apples`.

### Precision-Recall Curve  
Next, we would like to see how well our model is doing on our data. We express our results as 
**`precision`** and **`recall`** where precision is defined as the minimum similarity score before a match is correct and 
recall the percentage of matches found at a certain minimum similarity score.  

Creating the visualizations is as simple as:

```
model.visualize_precision_recall()
```
<img src="images/tfidf.png" width="100%" height="100%"/> 

## Models
Currently, the following models are implemented in PolyFuzz:
* TF-IDF
* EditDistance (you can use any distance measure, see [documentation](https://maartengr.github.io/PolyFuzz/tutorial/models/#EditDistance))
* FastText and GloVe
* 🤗 Transformers

With `Flair`, we can use all 🤗 Transformers [models](https://huggingface.co/transformers/pretrained_models.html). 
We simply have to instantiate any Flair WordEmbedding method and pass it through PolyFuzzy.

All models listed above can be found in `polyfuzz.models` and can be used to create and compare different models:

```python
from polyfuzz.models import EditDistance, TFIDF, Embeddings
from flair.embeddings import TransformerWordEmbeddings

embeddings = TransformerWordEmbeddings('bert-base-multilingual-cased')
bert = Embeddings(embeddings, min_similarity=0, model_id="BERT")
tfidf = TFIDF(min_similarity=0)
edit = EditDistance()

string_models = [bert, tfidf, edit]
model = PolyFuzz(string_models)
model.match(from_list, to_list)
```

To access the results, we again can call `get_matches` but since we have multiple models we get back a dictionary 
of dataframes back. 

In order to access the results of a specific model, call `get_matches` with the correct id: 

```python
>>> model.get_matches("BERT")
        From	    To          Similarity
0	apple	    apple	1.000000
1	apples	    apples	1.000000
2	appl	    apple	0.928045
3	recal	    apples	0.825268
4	house	    mouse	0.887524
5	similarity  mouse	0.791548
``` 

Finally, visualize the results to compare the models:

```python
model.visualize_precision_recall(kde=True)
```

<img src="images/multiple_models.png" width="100%" height="100%"/>

## Custom Grouper
We can even use one of the `polyfuzz.models` to be used as the grouper in case you would like to use 
something else than the standard TF-IDF model:

```python
model = PolyFuzz("TF-IDF")
model.match(from_list, to_list)

edit_grouper = EditDistance(n_jobs=1)
model.group(edit_grouper)
```

## Custom Models
Although the options above are a great solution for comparing different models, what if you have developed your own? 
If you follow the structure of PolyFuzz's `BaseMatcher`  
you can quickly implement any model you would like.

Below, we are implementing the ratio similarity measure from RapidFuzz.

```python
import numpy as np
import pandas as pd
from rapidfuzz import fuzz
from polyfuzz.models import BaseMatcher


class MyModel(BaseMatcher):
    def match(self, from_list, to_list, **kwargs):
        # Calculate distances
        matches = [[fuzz.ratio(from_string, to_string) / 100 for to_string in to_list] 
                    for from_string in from_list]
        
        # Get best matches
        mappings = [to_list[index] for index in np.argmax(matches, axis=1)]
        scores = np.max(matches, axis=1)
        
        # Prepare dataframe
        matches = pd.DataFrame({'From': from_list,'To': mappings, 'Similarity': scores})
        return matches
```
Then, we can simply create an instance of MyModel and pass it through PolyFuzz:
```python
custom_model = MyModel()
model = PolyFuzz(custom_model)
```

## Citation
To cite PolyFuzz in your work, please use the following bibtex reference:

```bibtex
@misc{grootendorst2020polyfuzz,
  author       = {Maarten Grootendorst},
  title        = {PolyFuzz: Fuzzy string matching, grouping, and evaluation.},
  year         = 2020,
  publisher    = {Zenodo},
  version      = {v0.2.2},
  doi          = {10.5281/zenodo.4461050},
  url          = {https://doi.org/10.5281/zenodo.4461050}
}
```

## References
Below, you can find several resources that were used for or inspired by when developing PolyFuzz:  
  
**Edit distance algorithms**:  
These algorithms focus primarily on edit distance measures and can be used in `polyfuzz.models.EditDistance`:

* https://github.com/jamesturk/jellyfish
* https://github.com/ztane/python-Levenshtein
* https://github.com/seatgeek/fuzzywuzzy
* https://github.com/maxbachmann/rapidfuzz
* https://github.com/roy-ht/editdistance

**Other interesting repos**:

* https://github.com/ing-bank/sparse_dot_topn
    * Used in PolyFuzz for fast cosine similarity between sparse matrices



            

Raw data

            {
    "_id": null,
    "home_page": "https://github.com/MaartenGr/PolyFuzz",
    "name": "polyfuzz",
    "maintainer": "",
    "docs_url": null,
    "requires_python": ">=3.6",
    "maintainer_email": "",
    "keywords": "nlp string matching embeddings levenshtein tfidf bert",
    "author": "Maarten Grootendorst",
    "author_email": "maartengrootendorst@gmail.com",
    "download_url": "https://files.pythonhosted.org/packages/b0/09/bb9e951292f21935be8cc73a01ef403383c3ea52bb237a9dba91ed637a40/polyfuzz-0.4.2.tar.gz",
    "platform": null,
    "description": "<img src=\"images/logo.png\" width=\"70%\" height=\"70%\"/>\n\n[![PyPI - Python](https://img.shields.io/badge/python-3.6%20|%203.7%20|%203.8-blue.svg)](https://pypi.org/project/keybert/)\n[![PyPI - License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/MaartenGr/keybert/blob/master/LICENSE)\n[![PyPI - PyPi](https://img.shields.io/pypi/v/polyfuzz)](https://pypi.org/project/polyfuzz/)\n[![Build](https://img.shields.io/github/workflow/status/MaartenGr/polyfuzz/Code%20Checks/master)](https://pypi.org/project/polyfuzz/)\n[![docs](https://img.shields.io/badge/docs-Passing-green.svg)](https://maartengr.github.io/PolyFuzz/)  \n**`PolyFuzz`** performs fuzzy string matching, string grouping, and contains extensive evaluation functions. \nPolyFuzz is meant to bring fuzzy string matching techniques together within a single framework.\n\nCurrently, methods include a variety of edit distance measures, a character-based n-gram TF-IDF, word embedding\ntechniques such as FastText and GloVe, and \u00f0\u0178\u00a4\u2014 transformers embeddings.  \n\nCorresponding medium post can be found [here](https://towardsdatascience.com/string-matching-with-bert-tf-idf-and-more-274bb3a95136?source=friends_link&sk=0f765b76ceaba49363829c13dfdc9d98).\n\n\n<a name=\"installation\"/></a>\n## Installation\nYou can install **`PolyFuzz`** via pip:\n \n```bash\npip install polyfuzz\n```\n\nYou may want to install more depending on the transformers and language backends that you will be using. The possible installations are:\n\n```python\npip install polyfuzz[sbert]\npip install polyfuzz[flair]\npip install polyfuzz[gensim]\npip install polyfuzz[spacy]\npip install polyfuzz[use]\n```\n\nIf you want to speed up the cosine similarity comparison and decrease memory usage when using embedding models, \nyou can use `sparse_dot_topn` which is installed via:\n\n```bash\npip install polyfuzz[fast]\n```\n\n<details>\n<summary>Installation Issues</summary>\n\nYou might run into installation issues with `sparse_dot_topn`. If so, one solution that has worked for many \nis by installing it via conda first before installing PolyFuzz:\n\n```bash\nconda install -c conda-forge sparse_dot_topn\n```\n\nIf that does not work, I would advise you to look through their \nissues](https://github.com/ing-bank/sparse_dot_topn/issues) page or continue to use PolyFuzz without `sparse_dot_topn`. \n\n</details>  \n\n\n<a name=\"gettingstarted\"/></a>\n## Getting Started\n\nFor an in-depth overview of the possibilities of `PolyFuzz` \nyou can check the full documentation [here](https://maartengr.github.io/PolyFuzz/) or you can follow along \nwith the notebook [here](https://github.com/MaartenGr/PolyFuzz/blob/master/notebooks/Overview.ipynb).\n\n### Quick Start\n\nThe main goal of `PolyFuzz` is to allow the user to perform different methods for matching strings. \nWe start by defining two lists, one to map from and one to map to. We are going to be using `TF-IDF` to create \nn-grams on a character level in order to compare similarity between strings. Then, we calculate the similarity \nbetween strings by calculating the cosine similarity between vector representations. \n\nWe only have to instantiate `PolyFuzz` with `TF-IDF` and match the lists:\n\n```python\nfrom polyfuzz import PolyFuzz\n\nfrom_list = [\"apple\", \"apples\", \"appl\", \"recal\", \"house\", \"similarity\"]\nto_list = [\"apple\", \"apples\", \"mouse\"]\n\nmodel = PolyFuzz(\"TF-IDF\")\nmodel.match(from_list, to_list)\n```  \n\nThe resulting matches can be accessed through `model.get_matches()`:\n\n```python\n>>> model.get_matches()\n         From      To    Similarity\n0       apple   apple    1.000000\n1      apples  apples    1.000000\n2        appl   apple    0.783751\n3       recal    None    0.000000\n4       house   mouse    0.587927\n5  similarity    None    0.000000\n\n``` \n\n**NOTE 1**: If you want to compare distances within a single list, you can simply pass that list as such: `model.match(from_list)`\n\n**NOTE 2**: When instantiating `PolyFuzz` we also could have used \"EditDistance\" or \"Embeddings\" to quickly \naccess Levenshtein and FastText (English) respectively. \n\n### Production\nThe `.match` function allows you to quickly extract similar strings. However, after selecting the right models to be used, you may want to use PolyFuzz \nin production to match incoming strings. To do so, we can make use of the familiar `fit`, `transform`, and `fit_transform` functions. \n\nLet's say that we have a list of words that we know to be correct called `train_words`. We want to any incoming word to mapped to one of the words in `train_words`. \nIn other words, we `fit` on `train_words` and we use `transform` on any incoming words:\n\n```python\nfrom sklearn.datasets import fetch_20newsgroups\nfrom sklearn.feature_extraction.text import CountVectorizer\nfrom polyfuzz import PolyFuzz\n\ntrain_words = [\"apple\", \"apples\", \"appl\", \"recal\", \"house\", \"similarity\"]\nunseen_words = [\"apple\", \"apples\", \"mouse\"]\n\n# Fit\nmodel = PolyFuzz(\"TF-IDF\")\nmodel.fit(train_words)\n\n# Transform\nresults = model.transform(unseen_words)\n```\n\nIn the above example, we are using `fit` on `train_words` to calculate the TF-IDF representation of those words which are saved to be used again in `transform`. \nThis speeds up `transform` quite a bit since all TF-IDF representations are stored when applying `fit`. \n\nThen, we apply save and load the model as follows to be used in production:\n\n```python\n# Save the model\nmodel.save(\"my_model\")\n\n# Load the model\nloaded_model = PolyFuzz.load(\"my_model\")\n```\n\n### Group Matches\nWe can group the matches `To` as there might be significant overlap in strings in our to_list. \nTo do this, we calculate the similarity within strings in to_list and use `single linkage` to then \ngroup the strings with a high similarity.\n\nWhen we extract the new matches, we can see an additional column `Group` in which all the `To` matches were grouped to:\n\n```python\n>>> model.group(link_min_similarity=0.75)\n>>> model.get_matches()\n\t      From\tTo\t\tSimilarity\tGroup\n0\t     apple\tapple\t1.000000\tapples\n1\t    apples\tapples\t1.000000\tapples\n2\t      appl\tapple\t0.783751\tapples\n3\t     recal\tNone\t0.000000\tNone\n4\t     house\tmouse\t0.587927\tmouse\n5\tsimilarity\tNone\t0.000000\tNone\n```\n\nAs can be seen above, we grouped apple and apples together to `apple` such that when a string is mapped to `apple` it \nwill fall in the cluster of `[apples, apple]` and will be mapped to the first instance in the cluster which is `apples`.\n\n### Precision-Recall Curve  \nNext, we would like to see how well our model is doing on our data. We express our results as \n**`precision`** and **`recall`** where precision is defined as the minimum similarity score before a match is correct and \nrecall the percentage of matches found at a certain minimum similarity score.  \n\nCreating the visualizations is as simple as:\n\n```\nmodel.visualize_precision_recall()\n```\n<img src=\"images/tfidf.png\" width=\"100%\" height=\"100%\"/> \n\n## Models\nCurrently, the following models are implemented in PolyFuzz:\n* TF-IDF\n* EditDistance (you can use any distance measure, see [documentation](https://maartengr.github.io/PolyFuzz/tutorial/models/#EditDistance))\n* FastText and GloVe\n* \u00f0\u0178\u00a4\u2014 Transformers\n\nWith `Flair`, we can use all \u00f0\u0178\u00a4\u2014 Transformers [models](https://huggingface.co/transformers/pretrained_models.html). \nWe simply have to instantiate any Flair WordEmbedding method and pass it through PolyFuzzy.\n\nAll models listed above can be found in `polyfuzz.models` and can be used to create and compare different models:\n\n```python\nfrom polyfuzz.models import EditDistance, TFIDF, Embeddings\nfrom flair.embeddings import TransformerWordEmbeddings\n\nembeddings = TransformerWordEmbeddings('bert-base-multilingual-cased')\nbert = Embeddings(embeddings, min_similarity=0, model_id=\"BERT\")\ntfidf = TFIDF(min_similarity=0)\nedit = EditDistance()\n\nstring_models = [bert, tfidf, edit]\nmodel = PolyFuzz(string_models)\nmodel.match(from_list, to_list)\n```\n\nTo access the results, we again can call `get_matches` but since we have multiple models we get back a dictionary \nof dataframes back. \n\nIn order to access the results of a specific model, call `get_matches` with the correct id: \n\n```python\n>>> model.get_matches(\"BERT\")\n        From\t    To          Similarity\n0\tapple\t    apple\t1.000000\n1\tapples\t    apples\t1.000000\n2\tappl\t    apple\t0.928045\n3\trecal\t    apples\t0.825268\n4\thouse\t    mouse\t0.887524\n5\tsimilarity  mouse\t0.791548\n``` \n\nFinally, visualize the results to compare the models:\n\n```python\nmodel.visualize_precision_recall(kde=True)\n```\n\n<img src=\"images/multiple_models.png\" width=\"100%\" height=\"100%\"/>\n\n## Custom Grouper\nWe can even use one of the `polyfuzz.models` to be used as the grouper in case you would like to use \nsomething else than the standard TF-IDF model:\n\n```python\nmodel = PolyFuzz(\"TF-IDF\")\nmodel.match(from_list, to_list)\n\nedit_grouper = EditDistance(n_jobs=1)\nmodel.group(edit_grouper)\n```\n\n## Custom Models\nAlthough the options above are a great solution for comparing different models, what if you have developed your own? \nIf you follow the structure of PolyFuzz's `BaseMatcher`  \nyou can quickly implement any model you would like.\n\nBelow, we are implementing the ratio similarity measure from RapidFuzz.\n\n```python\nimport numpy as np\nimport pandas as pd\nfrom rapidfuzz import fuzz\nfrom polyfuzz.models import BaseMatcher\n\n\nclass MyModel(BaseMatcher):\n    def match(self, from_list, to_list, **kwargs):\n        # Calculate distances\n        matches = [[fuzz.ratio(from_string, to_string) / 100 for to_string in to_list] \n                    for from_string in from_list]\n        \n        # Get best matches\n        mappings = [to_list[index] for index in np.argmax(matches, axis=1)]\n        scores = np.max(matches, axis=1)\n        \n        # Prepare dataframe\n        matches = pd.DataFrame({'From': from_list,'To': mappings, 'Similarity': scores})\n        return matches\n```\nThen, we can simply create an instance of MyModel and pass it through PolyFuzz:\n```python\ncustom_model = MyModel()\nmodel = PolyFuzz(custom_model)\n```\n\n## Citation\nTo cite PolyFuzz in your work, please use the following bibtex reference:\n\n```bibtex\n@misc{grootendorst2020polyfuzz,\n  author       = {Maarten Grootendorst},\n  title        = {PolyFuzz: Fuzzy string matching, grouping, and evaluation.},\n  year         = 2020,\n  publisher    = {Zenodo},\n  version      = {v0.2.2},\n  doi          = {10.5281/zenodo.4461050},\n  url          = {https://doi.org/10.5281/zenodo.4461050}\n}\n```\n\n## References\nBelow, you can find several resources that were used for or inspired by when developing PolyFuzz:  \n  \n**Edit distance algorithms**:  \nThese algorithms focus primarily on edit distance measures and can be used in `polyfuzz.models.EditDistance`:\n\n* https://github.com/jamesturk/jellyfish\n* https://github.com/ztane/python-Levenshtein\n* https://github.com/seatgeek/fuzzywuzzy\n* https://github.com/maxbachmann/rapidfuzz\n* https://github.com/roy-ht/editdistance\n\n**Other interesting repos**:\n\n* https://github.com/ing-bank/sparse_dot_topn\n    * Used in PolyFuzz for fast cosine similarity between sparse matrices\n\n\n",
    "bugtrack_url": null,
    "license": "",
    "summary": "PolyFuzz performs fuzzy string matching, grouping, and evaluation.",
    "version": "0.4.2",
    "project_urls": {
        "Documentation": "https://maartengr.github.io/polyfuzz/",
        "Homepage": "https://github.com/MaartenGr/PolyFuzz",
        "Issue Tracker": "https://github.com/MaartenGr/PolyFuzz/issues",
        "Source Code": "https://github.com/MaartenGr/PolyFuzz/"
    },
    "split_keywords": [
        "nlp",
        "string",
        "matching",
        "embeddings",
        "levenshtein",
        "tfidf",
        "bert"
    ],
    "urls": [
        {
            "comment_text": "",
            "digests": {
                "blake2b_256": "a9700bd0c2570fc64ac1d3dacef2e8c1a1f8028fd8368fe66da90b3f19457501",
                "md5": "fea03cb26baa4d11b467b1f42c32b32f",
                "sha256": "f2a2f584fc479e3de6032c4ffa15c890115c3bc386fa775d7adbc144c9c5b282"
            },
            "downloads": -1,
            "filename": "polyfuzz-0.4.2-py2.py3-none-any.whl",
            "has_sig": false,
            "md5_digest": "fea03cb26baa4d11b467b1f42c32b32f",
            "packagetype": "bdist_wheel",
            "python_version": "py2.py3",
            "requires_python": ">=3.6",
            "size": 36627,
            "upload_time": "2023-09-03T07:51:55",
            "upload_time_iso_8601": "2023-09-03T07:51:55.113600Z",
            "url": "https://files.pythonhosted.org/packages/a9/70/0bd0c2570fc64ac1d3dacef2e8c1a1f8028fd8368fe66da90b3f19457501/polyfuzz-0.4.2-py2.py3-none-any.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": "",
            "digests": {
                "blake2b_256": "b009bb9e951292f21935be8cc73a01ef403383c3ea52bb237a9dba91ed637a40",
                "md5": "925fe59b5f2822633fe1dd36b76ce91c",
                "sha256": "0e3ef5e9038a9ecd40babb91776f48c6181a3201919246940f5bd0712354aaf8"
            },
            "downloads": -1,
            "filename": "polyfuzz-0.4.2.tar.gz",
            "has_sig": false,
            "md5_digest": "925fe59b5f2822633fe1dd36b76ce91c",
            "packagetype": "sdist",
            "python_version": "source",
            "requires_python": ">=3.6",
            "size": 28125,
            "upload_time": "2023-09-03T07:51:57",
            "upload_time_iso_8601": "2023-09-03T07:51:57.663986Z",
            "url": "https://files.pythonhosted.org/packages/b0/09/bb9e951292f21935be8cc73a01ef403383c3ea52bb237a9dba91ed637a40/polyfuzz-0.4.2.tar.gz",
            "yanked": false,
            "yanked_reason": null
        }
    ],
    "upload_time": "2023-09-03 07:51:57",
    "github": true,
    "gitlab": false,
    "bitbucket": false,
    "codeberg": false,
    "github_user": "MaartenGr",
    "github_project": "PolyFuzz",
    "travis_ci": false,
    "coveralls": false,
    "github_actions": true,
    "lcname": "polyfuzz"
}
        
Elapsed time: 2.69875s