strprob 1.0.2__tar.gz

strprob-1.0.2/LICENSE

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright © 2026 Stephen Mather, spmather, smather
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

strprob-1.0.2/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: strprob
+Version: 1.0.2
+Summary: A string comparison tool
+Home-page: https://github.com/spmather/pstr
+Author-email: spmather <spm-pypi-issues@pm.me>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/spmather/pstr
+Project-URL: Issues, https://github.com/spmather/pstr/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: string
+Requires-Dist: argparse
+Dynamic: license-file
+
+# Pstr "strprob"
+
+Pstr or strprob is a small fuzzy string comparison tool in python for comparing two strings and how closely they match using the equation:  `( (common words/total words) + (common characters/total characters) ) / (the mean of the input)`.  The output is an number between 0 and 1, including float values.
+
+# When to use
+
+There are a few times when a regex is not powerful enough without significant modification to compare strings for matching.  I created this fuzzy string to accomodate specific needs I had.
+
+# Math
+
+The equation that is calculated is a probability range from 0 to 1 based on how closely the strings match characters and words.
+
+##### Working through the math
+
+A single word comparison:  `Car` and `Cat` 
+
+```
+# Comparing Characters
+C = C ... 100%
+A = A ... 100%
+R != T ... 0%
+# Matches/Total = 4/6
+# Result:  0.66 match
+
+
+# Comparing words
+Cat != Car ... 0%
+# Matches/Total = 0/2
+# Result: 0.00 match
+
+
+# Mean of characters and words
+0.66 + 0.00 / 2 = 0.33 or 33% match
+```
+
+A multiple word comparison:  `Hello my new friend` and `Hello my old friend`
+
+```
+# Comparing Characters
+H = H ... 100%
+E = E ... 100%
+L = L ... 100%
+L = L ... 100%
+O = O ... 100%
+M = M ... 100%
+Y = Y ... 100%
+N != O ... 0%
+E != L ... 0%
+W != D ... 0%
+F = F ... 100%
+R = R ... 100%
+I = I ... 100%
+E = E ... 100%
+N = N ... 100%
+D = D ... 100%
+# Matches/Total = 26/32
+# Result:  0.8125 match
+
+
+# Comparing words
+Hello = Hello ... 100%
+My = My ... 100%
+New != Old ... 0%
+Friend = Friend ... 100%
+# Matches/Total = 6/8
+# Result: 0.75 match
+
+
+# Mean of characters and words
+(0.8125 + 0.75) / 2 = 0.78125 or 78.125% match
+```
+
+
+
+##### Accuracy
+
+I have used this over several workloads and typically, I will put the accuracy threshhold at `0.859` for important work.  I.E.
+
+```powershell
+if ($pstrValue -gt 0.859) {
+    # do your command
+}
+```
+
+I also find it to have excellent use at the end of any `if` chains/statements involving matching a string to regex or any string-related validation:
+
+```powershell
+if ($something -match $regex) {
+    # do your command
+}
+elseif ($pstrValue -gt 0.859) {
+    # do your command
+}
+```
+
+##### In summary
+
+1. Above `0.949` = Too high for most uses
+
+2. `0.859` = Highly accurate
+
+3. `0.799` = Pretty good accurate
+
+4. `0.649` = Absolute minimum for most uses
+
+5. Below `0.549` = Patently inaccurate
+
+##### Windows
+
+```powershell
+pip install pstr
+```
+
+
+
+##### Linux
+
+If the package is not added to your distro's repo, then you need to create a venv like this:
+
+```bash
+# Makes a directory at a path.  Change 
+#     "/path/to/new/virtual/environment"
+#     to an actual path in your file system
+mkdir /path/to/new/virtual/environment
+
+# Create the virtual environment
+# Some distros do not come packaged with venv
+#    follow the install prompts to add python3-venv
+#    if applicable
+python -m venv /path/to/new/virtual/environment
+
+# Use the new venv
+source /path/to/new/virtual/environment/bin/activate
+
+# Install the pstr package
+pip install pstr
+```
+
+
+
+##### Next use the following syntax
+
+From PowerShell or Bash
+
+1. Example 1:  Comparing the similarity of `"string 1 here"` and `"string 2 here"`
+
+```
+./pstr.py pstr "string 1 here" "string 2 here"
+```
+
+2. Example 2:  Comparing the similarity of `"string 1 here"` and `"string 2 here"` but with debug
+
+   
+
+```
+./pstr.py pstrd "string 1 here" "string 2 here"
+```
+
+### Future plans
+1. add case insensitive options
+2. fix the brute force recursion in some cases where 1,000 iterations doesn't remove items from the character lists

strprob-1.0.2/README.md

@@ -0,0 +1,161 @@
+# Pstr "strprob"
+
+Pstr or strprob is a small fuzzy string comparison tool in python for comparing two strings and how closely they match using the equation:  `( (common words/total words) + (common characters/total characters) ) / (the mean of the input)`.  The output is an number between 0 and 1, including float values.
+
+# When to use
+
+There are a few times when a regex is not powerful enough without significant modification to compare strings for matching.  I created this fuzzy string to accomodate specific needs I had.
+
+# Math
+
+The equation that is calculated is a probability range from 0 to 1 based on how closely the strings match characters and words.
+
+##### Working through the math
+
+A single word comparison:  `Car` and `Cat` 
+
+```
+# Comparing Characters
+C = C ... 100%
+A = A ... 100%
+R != T ... 0%
+# Matches/Total = 4/6
+# Result:  0.66 match
+
+
+# Comparing words
+Cat != Car ... 0%
+# Matches/Total = 0/2
+# Result: 0.00 match
+
+
+# Mean of characters and words
+0.66 + 0.00 / 2 = 0.33 or 33% match
+```
+
+A multiple word comparison:  `Hello my new friend` and `Hello my old friend`
+
+```
+# Comparing Characters
+H = H ... 100%
+E = E ... 100%
+L = L ... 100%
+L = L ... 100%
+O = O ... 100%
+M = M ... 100%
+Y = Y ... 100%
+N != O ... 0%
+E != L ... 0%
+W != D ... 0%
+F = F ... 100%
+R = R ... 100%
+I = I ... 100%
+E = E ... 100%
+N = N ... 100%
+D = D ... 100%
+# Matches/Total = 26/32
+# Result:  0.8125 match
+
+
+# Comparing words
+Hello = Hello ... 100%
+My = My ... 100%
+New != Old ... 0%
+Friend = Friend ... 100%
+# Matches/Total = 6/8
+# Result: 0.75 match
+
+
+# Mean of characters and words
+(0.8125 + 0.75) / 2 = 0.78125 or 78.125% match
+```
+
+
+
+##### Accuracy
+
+I have used this over several workloads and typically, I will put the accuracy threshhold at `0.859` for important work.  I.E.
+
+```powershell
+if ($pstrValue -gt 0.859) {
+    # do your command
+}
+```
+
+I also find it to have excellent use at the end of any `if` chains/statements involving matching a string to regex or any string-related validation:
+
+```powershell
+if ($something -match $regex) {
+    # do your command
+}
+elseif ($pstrValue -gt 0.859) {
+    # do your command
+}
+```
+
+##### In summary
+
+1. Above `0.949` = Too high for most uses
+
+2. `0.859` = Highly accurate
+
+3. `0.799` = Pretty good accurate
+
+4. `0.649` = Absolute minimum for most uses
+
+5. Below `0.549` = Patently inaccurate
+
+##### Windows
+
+```powershell
+pip install pstr
+```
+
+
+
+##### Linux
+
+If the package is not added to your distro's repo, then you need to create a venv like this:
+
+```bash
+# Makes a directory at a path.  Change 
+#     "/path/to/new/virtual/environment"
+#     to an actual path in your file system
+mkdir /path/to/new/virtual/environment
+
+# Create the virtual environment
+# Some distros do not come packaged with venv
+#    follow the install prompts to add python3-venv
+#    if applicable
+python -m venv /path/to/new/virtual/environment
+
+# Use the new venv
+source /path/to/new/virtual/environment/bin/activate
+
+# Install the pstr package
+pip install pstr
+```
+
+
+
+##### Next use the following syntax
+
+From PowerShell or Bash
+
+1. Example 1:  Comparing the similarity of `"string 1 here"` and `"string 2 here"`
+
+```
+./pstr.py pstr "string 1 here" "string 2 here"
+```
+
+2. Example 2:  Comparing the similarity of `"string 1 here"` and `"string 2 here"` but with debug
+
+   
+
+```
+./pstr.py pstrd "string 1 here" "string 2 here"
+```
+
+### Future plans
+1. add case insensitive options
+2. fix the brute force recursion in some cases where 1,000 iterations doesn't remove items from the character lists

strprob-1.0.2/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "strprob"
+version = "1.0.2"
+authors = [
+  { name="spmather", email="spm-pypi-issues@pm.me" },
+]
+description = "A string comparison tool"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent"
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+dependencies = [
+    "string",
+    "argparse"
+]
+
+[project.urls]
+Homepage = "https://github.com/spmather/pstr"
+Issues = "https://github.com/spmather/pstr/issues"

strprob-1.0.2/setup.cfg

@@ -0,0 +1,21 @@
+[metadata]
+name = strprob
+version = 1.0.2
+authors = spmather
+author_email = spm-pypi-issues@pm.me
+description = A string comparison tool
+long_description = file: README.md
+long_description_content_type = text/markdown
+license = MIT
+url = https://github.com/spmather/pstr
+classifiers = 
+	Programming Language :: Python :: 3
+	Operating System :: OS Independent
+
+[options]
+python_requires = >=3.9
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

strprob-1.0.2/src/pstr/strprob.py

@@ -0,0 +1,204 @@
+#!/bin/python3
+
+# spmather
+# created 2026-07-15
+# updated 2026-08-04
+# packaged for pypi 2026-10-17
+# 1.0.2
+
+import string
+import argparse
+
+def pstrd(reference,difference):
+    """
+    Probability of two STRings matching (with Debug)... P STR D
+    using the equation
+    ((common words/total words)+(common characters/total characters))/2 or the mean of the input
+
+    """
+ 
+    # Formats words in a string as a list
+    refword_l   = []
+    difword_l   = []
+    for sym in string.punctuation:
+        reference = reference.replace(sym,' ')
+    ref_replace = reference
+    print(f"Reference list with replacement {ref_replace}")
+    refword_l   = ref_replace.split()
+    print(f"Reference word list {refword_l}")
+    for sym in string.punctuation:
+        difference = difference.replace(sym,' ')
+    dif_replace = difference
+    print(f"Difference list with replacement {dif_replace}")
+    difword_l   = dif_replace.split()
+    print(f"Difference word list {difword_l}")
+
+    # Formats characters in a string as a list
+    refchar_l = list(ref_replace.lower().replace(' ',''))
+    print(f"Reference character list is {refchar_l}")
+    difchar_l = list(dif_replace.lower().replace(' ',''))
+    print(f"Difference character list is {difchar_l}")
+
+    # Find the total number of characters
+    charlen = len(refchar_l) + len(difchar_l)
+    print(f"Total number of characters {charlen}")
+
+    # Find the total number of words
+    wordlen = len(refword_l) + len(difword_l)
+    print(f"Total number of words {wordlen}")
+
+    # Compare the values in character lists
+    sortrefchar_l = sorted(refchar_l)
+    sortdifchar_l = sorted(difchar_l)
+    commonchar_l  = []
+
+    # Brute force iterations
+    # I had issues with enumerate(zip()) missing letters
+    # In:  pstrd("Hello my old friend","Hello my new friend"), the letters m and r were excluded
+         
+    upperlimit = charlen ** 2
+    errorcount = 0
+
+    for i in range(charlen):
+        for refletter in sortrefchar_l:
+            for difletter in sortdifchar_l:
+                print(i)
+                print(f"~~~~ iteration count is {i} ~~~~")
+                if refletter == difletter:
+                    print(f"reference letter is {refletter}")
+                    print(f"difference letter is {difletter}")
+                    commonchar_l.append(refletter)
+                    commonchar_l.append(difletter)
+                    print(f"common character list is now {commonchar_l}")
+                    sortrefchar_l.remove(refletter)
+                    sortdifchar_l.remove(difletter)
+                    print(f"sorted reference character list is now {sortrefchar_l}")
+                    print(f"sorted difference character list is now {sortdifchar_l}")
+                else:
+                    errorcount += 1
+                    print(f"errorcount is {errorcount}")
+                if i > upperlimit:
+                    print(f"iteration {i} is over exponential limits {upperlimit}")
+                if errorcount == upperlimit:
+                    print(f"errorcount {errorcount} is at exponential limits {upperlimit}")
+                elif errorcount > upperlimit:
+                    print(f"errorcount {errorcount} is over exponential limits {upperlimit}")
+    print(f"Common characters are {commonchar_l}")
+    commoncharlen = len(commonchar_l)
+    print(f"Number of common characters {commoncharlen}")
+
+    # Divide Common characters by total characters
+    charpercent = commoncharlen / charlen
+    print(f"Percent of characters that are common {charpercent}")
+        
+    # Compare the values in word lists
+    #commonword_l  = list(set(refword_l) & set(difword_l))
+    sordrefword_l = sorted(refword_l)
+    sortdifword_l = sorted(difword_l) 
+    commonword_l = []
+    for i, (ref,dif) in enumerate(zip(sordrefword_l,sortdifword_l)):
+        if ref == dif:
+            print(f"refword is {ref}")
+            print(f"difword is {dif}")
+            commonword_l.append(ref)
+            commonword_l.append(dif)
+    print(f"Common words are {commonword_l}")
+    commonwordlen = len(commonword_l)
+    print(f"Total common words {commonwordlen}")
+
+    # Divide Common words by total words
+    wordpercent = commonwordlen / wordlen
+    print(f"Percent of words that are common {wordpercent}")
+
+    # Get the mean of common words and common characters
+    prob = (charpercent + wordpercent) / 2
+    
+    # End
+    return prob
+
+
+def pstr(reference,difference):
+    """
+    Probability of two STRings matching (with no debug)... P STR
+    using the equation
+    ((common words/total words)+(common characters/total characters))/2 or the mean of the input
+
+    """
+    refword_l   = []
+    difword_l   = []
+    for sym in string.punctuation:
+        reference = reference.replace(sym,' ')
+    ref_replace = reference
+    refword_l   = ref_replace.split()
+    for sym in string.punctuation:
+        difference = difference.replace(sym,' ')
+    dif_replace = difference
+    difword_l   = dif_replace.split()
+    refchar_l = list(ref_replace.lower().replace(' ',''))
+    difchar_l = list(dif_replace.lower().replace(' ',''))
+    charlen = len(refchar_l) + len(difchar_l)
+    wordlen = len(refword_l) + len(difword_l)
+    sortrefchar_l = sorted(refchar_l)
+    sortdifchar_l = sorted(difchar_l)
+    commonchar_l  = []
+    errorcount = 0
+    for i in range(charlen):
+        for refletter in sortrefchar_l:
+            for difletter in sortdifchar_l:
+                if refletter == difletter:
+                    commonchar_l.append(refletter)
+                    commonchar_l.append(difletter)
+                    sortrefchar_l.remove(refletter)
+                    sortdifchar_l.remove(difletter)
+                else:
+                    errorcount += 1
+    commoncharlen = len(commonchar_l)
+    charpercent = commoncharlen / charlen
+    sordrefword_l = sorted(refword_l)
+    sortdifword_l = sorted(difword_l) 
+    commonword_l = []
+    for i, (ref,dif) in enumerate(zip(sordrefword_l,sortdifword_l)):
+        if ref == dif:
+            commonword_l.append(ref)
+            commonword_l.append(dif)
+    commonwordlen = len(commonword_l)
+    wordpercent = commonwordlen / wordlen
+    prob = (charpercent + wordpercent) / 2
+    return prob
+
+
+def main():
+    """
+    Argparse added for functions to allow running from the terminal easily
+    Import note if running from terminal:  
+        I added argparse stuff for both functions:  
+        pstr "probability of strings" and pstrd "probability of strings with debug."
+        To execute (in case I forget later), use /path/to/file.py functionname param1 param2
+        i.e.  ~/Documents/pythonscripts/pstr.py pstrd "A car" "A cat"
+        Hypothetically, one can add the file to /bin/pstr without the file extension too. As long as 
+        it has +x permissions.
+    """
+    parser = argparse.ArgumentParser(description="probability of string match")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # pstr parameters
+    pstr_parser = subparsers.add_parser("pstr", help="probability of string match")
+    pstr_parser.add_argument("ref", type=str, help="reference string")
+    pstr_parser.add_argument("dif", type=str, help="difference string")
+
+    # pstrd parameters
+    pstrd_parser = subparsers.add_parser("pstrd", help="probability of string match with debug")
+    pstrd_parser.add_argument("ref", type=str, help="reference string")
+    pstrd_parser.add_argument("dif", type=str, help="difference string")
+
+    # Do the thing
+    doit = parser.parse_args()
+    if doit.command == "pstr":
+        print(pstr(doit.ref, doit.dif))
+    if doit.command == "pstrd":
+        print(pstrd(doit.ref, doit.dif))
+
+if __name__ == "__main__":
+    main()
+
+# fin

strprob-1.0.2/src/strprob.egg-info/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: strprob
+Version: 1.0.2
+Summary: A string comparison tool
+Home-page: https://github.com/spmather/pstr
+Author-email: spmather <spm-pypi-issues@pm.me>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/spmather/pstr
+Project-URL: Issues, https://github.com/spmather/pstr/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: string
+Requires-Dist: argparse
+Dynamic: license-file
+
+# Pstr "strprob"
+
+Pstr or strprob is a small fuzzy string comparison tool in python for comparing two strings and how closely they match using the equation:  `( (common words/total words) + (common characters/total characters) ) / (the mean of the input)`.  The output is an number between 0 and 1, including float values.
+
+# When to use
+
+There are a few times when a regex is not powerful enough without significant modification to compare strings for matching.  I created this fuzzy string to accomodate specific needs I had.
+
+# Math
+
+The equation that is calculated is a probability range from 0 to 1 based on how closely the strings match characters and words.
+
+##### Working through the math
+
+A single word comparison:  `Car` and `Cat` 
+
+```
+# Comparing Characters
+C = C ... 100%
+A = A ... 100%
+R != T ... 0%
+# Matches/Total = 4/6
+# Result:  0.66 match
+
+
+# Comparing words
+Cat != Car ... 0%
+# Matches/Total = 0/2
+# Result: 0.00 match
+
+
+# Mean of characters and words
+0.66 + 0.00 / 2 = 0.33 or 33% match
+```
+
+A multiple word comparison:  `Hello my new friend` and `Hello my old friend`
+
+```
+# Comparing Characters
+H = H ... 100%
+E = E ... 100%
+L = L ... 100%
+L = L ... 100%
+O = O ... 100%
+M = M ... 100%
+Y = Y ... 100%
+N != O ... 0%
+E != L ... 0%
+W != D ... 0%
+F = F ... 100%
+R = R ... 100%
+I = I ... 100%
+E = E ... 100%
+N = N ... 100%
+D = D ... 100%
+# Matches/Total = 26/32
+# Result:  0.8125 match
+
+
+# Comparing words
+Hello = Hello ... 100%
+My = My ... 100%
+New != Old ... 0%
+Friend = Friend ... 100%
+# Matches/Total = 6/8
+# Result: 0.75 match
+
+
+# Mean of characters and words
+(0.8125 + 0.75) / 2 = 0.78125 or 78.125% match
+```
+
+
+
+##### Accuracy
+
+I have used this over several workloads and typically, I will put the accuracy threshhold at `0.859` for important work.  I.E.
+
+```powershell
+if ($pstrValue -gt 0.859) {
+    # do your command
+}
+```
+
+I also find it to have excellent use at the end of any `if` chains/statements involving matching a string to regex or any string-related validation:
+
+```powershell
+if ($something -match $regex) {
+    # do your command
+}
+elseif ($pstrValue -gt 0.859) {
+    # do your command
+}
+```
+
+##### In summary
+
+1. Above `0.949` = Too high for most uses
+
+2. `0.859` = Highly accurate
+
+3. `0.799` = Pretty good accurate
+
+4. `0.649` = Absolute minimum for most uses
+
+5. Below `0.549` = Patently inaccurate
+
+##### Windows
+
+```powershell
+pip install pstr
+```
+
+
+
+##### Linux
+
+If the package is not added to your distro's repo, then you need to create a venv like this:
+
+```bash
+# Makes a directory at a path.  Change 
+#     "/path/to/new/virtual/environment"
+#     to an actual path in your file system
+mkdir /path/to/new/virtual/environment
+
+# Create the virtual environment
+# Some distros do not come packaged with venv
+#    follow the install prompts to add python3-venv
+#    if applicable
+python -m venv /path/to/new/virtual/environment
+
+# Use the new venv
+source /path/to/new/virtual/environment/bin/activate
+
+# Install the pstr package
+pip install pstr
+```
+
+
+
+##### Next use the following syntax
+
+From PowerShell or Bash
+
+1. Example 1:  Comparing the similarity of `"string 1 here"` and `"string 2 here"`
+
+```
+./pstr.py pstr "string 1 here" "string 2 here"
+```
+
+2. Example 2:  Comparing the similarity of `"string 1 here"` and `"string 2 here"` but with debug
+
+   
+
+```
+./pstr.py pstrd "string 1 here" "string 2 here"
+```
+
+### Future plans
+1. add case insensitive options
+2. fix the brute force recursion in some cases where 1,000 iterations doesn't remove items from the character lists

strprob-1.0.2/src/strprob.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+setup.cfg
+src/pstr/__init__.py
+src/pstr/strprob.py
+src/strprob.egg-info/PKG-INFO
+src/strprob.egg-info/SOURCES.txt
+src/strprob.egg-info/dependency_links.txt
+src/strprob.egg-info/requires.txt
+src/strprob.egg-info/top_level.txt

strprob-1.0.2/src/strprob.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

strprob-1.0.2/src/strprob.egg-info/requires.txt

@@ -0,0 +1,2 @@
+string
+argparse

strprob-1.0.2/src/strprob.egg-info/top_level.txt

@@ -0,0 +1 @@
+pstr