%global _empty_manifest_terminate_build 0 Name: python-fuzzy-match Version: 0.0.1 Release: 1 Summary: Fuzzy string matching in Python License: MIT URL: https://github.com/darwinagain/fuzzy-match Source0: https://mirrors.aliyun.com/pypi/web/packages/2f/88/7d2bc2d9d87d3c7437292def951ad8fbcb7956c3a8b9e250ec229623f01e/fuzzy-match-0.0.1.tar.gz BuildArch: noarch %description # Fuzzy-Match Fuzzy string matching in Python. By default it uses [Trigrams](https://en.wikipedia.org/wiki/Trigram) to calculate a similarity score and find matches by splitting strings into ngrams with a length of 3. The length of the ngram can be altered if desired. Also, [Cosine](https://en.wikipedia.org/wiki/Cosine_similarity), [Levenshtein Distance](https://en.wikipedia.org/wiki/Levenshtein_distance), and [Jaro-Winkler Distance](https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance) algorithims are also available as alternatives. # Usage ```python >>> from fuzzy_match import match >>> from fuzzy_match import algorithims ``` ### Trigram ```python >>> algorithims.trigram("this is a test string", "this is another test string") 0.703704 ``` ### Cosine ```python >>> algorithims.cosine("this is a test string", "this is another test string") 0.7999999999999998 ``` ### Levenshtein ```python >>> algorithims.levenshtein("this is a test string", "this is another test string") 0.7777777777777778 ``` ### Jaro-Winkler ```python >>> algorithims.jaro_winkler("this is a test string", "this is another test string") 0.798941798941799 ``` ### Match ```python >>> choices = ["simple strings", "strings are simple", "sim string", "string to match", "matching simple strings", "matching strings again"] >>> match.extract("simple string", choices, limit=2) [('simple strings', 0.8), ('sim string', 0.642857)] >>> match.extractOne("simple string", choices) ('simple strings', 0.8) ``` You can also pass additional arguments to `extract` and `extractOne` to set a score cutoff value or use one of the other algorithims mentioned above. Here is an example: ```python >>> match.extract("simple string", choices, match_type='levenshtein', score_cutoff=0.7) [('simple strings', 0.9285714285714286), ('sim string', 0.7692307692307693)] ``` `match_type` options include `trigram`, `cosine`, `levenshtein`, `jaro_winkler` %package -n python3-fuzzy-match Summary: Fuzzy string matching in Python Provides: python-fuzzy-match BuildRequires: python3-devel BuildRequires: python3-setuptools BuildRequires: python3-pip %description -n python3-fuzzy-match # Fuzzy-Match Fuzzy string matching in Python. By default it uses [Trigrams](https://en.wikipedia.org/wiki/Trigram) to calculate a similarity score and find matches by splitting strings into ngrams with a length of 3. The length of the ngram can be altered if desired. Also, [Cosine](https://en.wikipedia.org/wiki/Cosine_similarity), [Levenshtein Distance](https://en.wikipedia.org/wiki/Levenshtein_distance), and [Jaro-Winkler Distance](https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance) algorithims are also available as alternatives. # Usage ```python >>> from fuzzy_match import match >>> from fuzzy_match import algorithims ``` ### Trigram ```python >>> algorithims.trigram("this is a test string", "this is another test string") 0.703704 ``` ### Cosine ```python >>> algorithims.cosine("this is a test string", "this is another test string") 0.7999999999999998 ``` ### Levenshtein ```python >>> algorithims.levenshtein("this is a test string", "this is another test string") 0.7777777777777778 ``` ### Jaro-Winkler ```python >>> algorithims.jaro_winkler("this is a test string", "this is another test string") 0.798941798941799 ``` ### Match ```python >>> choices = ["simple strings", "strings are simple", "sim string", "string to match", "matching simple strings", "matching strings again"] >>> match.extract("simple string", choices, limit=2) [('simple strings', 0.8), ('sim string', 0.642857)] >>> match.extractOne("simple string", choices) ('simple strings', 0.8) ``` You can also pass additional arguments to `extract` and `extractOne` to set a score cutoff value or use one of the other algorithims mentioned above. Here is an example: ```python >>> match.extract("simple string", choices, match_type='levenshtein', score_cutoff=0.7) [('simple strings', 0.9285714285714286), ('sim string', 0.7692307692307693)] ``` `match_type` options include `trigram`, `cosine`, `levenshtein`, `jaro_winkler` %package help Summary: Development documents and examples for fuzzy-match Provides: python3-fuzzy-match-doc %description help # Fuzzy-Match Fuzzy string matching in Python. By default it uses [Trigrams](https://en.wikipedia.org/wiki/Trigram) to calculate a similarity score and find matches by splitting strings into ngrams with a length of 3. The length of the ngram can be altered if desired. Also, [Cosine](https://en.wikipedia.org/wiki/Cosine_similarity), [Levenshtein Distance](https://en.wikipedia.org/wiki/Levenshtein_distance), and [Jaro-Winkler Distance](https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance) algorithims are also available as alternatives. # Usage ```python >>> from fuzzy_match import match >>> from fuzzy_match import algorithims ``` ### Trigram ```python >>> algorithims.trigram("this is a test string", "this is another test string") 0.703704 ``` ### Cosine ```python >>> algorithims.cosine("this is a test string", "this is another test string") 0.7999999999999998 ``` ### Levenshtein ```python >>> algorithims.levenshtein("this is a test string", "this is another test string") 0.7777777777777778 ``` ### Jaro-Winkler ```python >>> algorithims.jaro_winkler("this is a test string", "this is another test string") 0.798941798941799 ``` ### Match ```python >>> choices = ["simple strings", "strings are simple", "sim string", "string to match", "matching simple strings", "matching strings again"] >>> match.extract("simple string", choices, limit=2) [('simple strings', 0.8), ('sim string', 0.642857)] >>> match.extractOne("simple string", choices) ('simple strings', 0.8) ``` You can also pass additional arguments to `extract` and `extractOne` to set a score cutoff value or use one of the other algorithims mentioned above. Here is an example: ```python >>> match.extract("simple string", choices, match_type='levenshtein', score_cutoff=0.7) [('simple strings', 0.9285714285714286), ('sim string', 0.7692307692307693)] ``` `match_type` options include `trigram`, `cosine`, `levenshtein`, `jaro_winkler` %prep %autosetup -n fuzzy-match-0.0.1 %build %py3_build %install %py3_install install -d -m755 %{buildroot}/%{_pkgdocdir} if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi pushd %{buildroot} if [ -d usr/lib ]; then find usr/lib -type f -printf "\"/%h/%f\"\n" >> filelist.lst fi if [ -d usr/lib64 ]; then find usr/lib64 -type f -printf "\"/%h/%f\"\n" >> filelist.lst fi if [ -d usr/bin ]; then find usr/bin -type f -printf "\"/%h/%f\"\n" >> filelist.lst fi if [ -d usr/sbin ]; then find usr/sbin -type f -printf "\"/%h/%f\"\n" >> filelist.lst fi touch doclist.lst if [ -d usr/share/man ]; then find usr/share/man -type f -printf "\"/%h/%f.gz\"\n" >> doclist.lst fi popd mv %{buildroot}/filelist.lst . mv %{buildroot}/doclist.lst . %files -n python3-fuzzy-match -f filelist.lst %dir %{python3_sitelib}/* %files help -f doclist.lst %{_docdir}/* %changelog * Thu Jun 08 2023 Python_Bot - 0.0.1-1 - Package Spec generated