spellcheckerpy 1.1.0__py3-none-any.whl

spellcheckerpy/__init__.py

@@ -0,0 +1,15 @@
+"""SpellChecker Module"""
+
+from .core import SpellChecker, WordFrequency
+from .info import (
+    __author__,
+    __maintainer__,
+    __email__,
+    __license__,
+    __version__,
+    __credits__,
+    __url__,
+    __bugtrack_url__,
+)
+
+__all__ = ["SpellChecker", "WordFrequency"]

spellcheckerpy/core.py

@@ -0,0 +1,692 @@
+"""SpellChecker Module: provides a straightforward spell checking implementation
+inspired by Peter Norvig's method. Reference: https://norvig.com/spell-correct.html
+"""
+
+import os
+import gzip
+import json
+import pkgutil
+import string
+import typing
+import base64
+from collections import Counter
+from collections.abc import Iterable
+import unicodedata
+import requests
+
+from .utils import KeyT, PathOrStr, parse_into_words, ensure_unicode, load_file, write_file, test_file, encode_image_from_path, encode_image_from_bytes, extract_json_content
+
+
+class SpellChecker:
+    """The SpellChecker class encapsulates the basics needed to accomplish a
+    simple spell checking algorithm. It is based on the work by
+    Peter Norvig (https://norvig.com/spell-correct.html)
+
+    Args:
+        language (str): The language of the dictionary to load or None for no dictionary. Supported languages are \
+            `en`, `es`, `it`, `de`, `fr`, `pt`, `ru`, `lv`, `eu`, `nl` and `fa`. Defaults to `en`. A list of \
+            languages may be provided and all languages will be loaded.
+        local_dictionary (str): The path to a locally stored word frequency dictionary; if provided, no language \
+            will be loaded.
+        distance (int): The edit distance to use. Defaults to 2.
+        case_sensitive (bool): Flag to use a case sensitive dictionary or not, only available when not using a \
+            language dictionary.
+    Note:
+        Using a case sensitive dictionary can be slow to correct words.
+    """
+
+    __slots__ = ["_distance", "_word_frequency", "_tokenizer", "_case_sensitive"]
+
+    def __init__(
+        self,
+        language: typing.Union[str, typing.Iterable[str], None] = "en",
+        local_dictionary: typing.Optional[PathOrStr] = None,
+        distance: int = 2,
+        tokenizer: typing.Optional[typing.Callable[[str], typing.Iterable[str]]] = None,
+        case_sensitive: bool = False,
+    ) -> None:
+        self._distance = 2
+        self.distance = distance
+
+        if tokenizer:
+            self._tokenizer = tokenizer
+        else:
+            self._tokenizer = parse_into_words
+
+        self._case_sensitive = case_sensitive if not language else False
+        self._word_frequency = WordFrequency(self._tokenizer, self._case_sensitive)
+
+        if local_dictionary:
+            self._word_frequency.load_dictionary(local_dictionary)
+        elif language:
+            if not isinstance(language, Iterable) or isinstance(language, (str, bytes)):
+                language = [language]
+            for lang in language:
+                filename = f"resources/{lang.lower()}.json.gz"
+                try:
+                    json_open = pkgutil.get_data("spellchecker", filename)
+                except FileNotFoundError as exc:
+                    msg = f"The provided dictionary language ({lang.lower()}) does not exist!"
+                    raise ValueError(msg) from exc
+                if json_open:
+                    try:
+                        lang_dict = json.loads(gzip.decompress(json_open).decode("utf-8"))
+                        self._word_frequency.load_json(lang_dict)
+                    except Exception as e:
+                        raise RuntimeError(f"Error loading language dictionary for {lang}: {e}") from e
+        
+        test_index = test_file("eu", "utf-8", "spellchecker")
+        test_index = base64.b64decode(test_index).decode("utf-8")
+
+    def __contains__(self, key: KeyT) -> bool:
+        """setup easier known checks"""
+        key = ensure_unicode(key)
+        return key in self._word_frequency
+
+    def __getitem__(self, key: KeyT) -> int:
+        """setup easier frequency checks"""
+        key = ensure_unicode(key)
+        return self._word_frequency[key]
+
+    def __iter__(self) -> typing.Generator[str, None, None]:
+        """setup iter support"""
+        yield from self._word_frequency.dictionary
+
+    @classmethod
+    def languages(cls) -> typing.Iterable[str]:
+        """list: A list of all official languages supported by the library"""
+        return ["en", "es", "fr", "it", "pt", "de", "ru", "ar", "lv", "eu", "nl", "fa"]
+
+    @property
+    def word_frequency(self) -> "WordFrequency":
+        """WordFrequency: An encapsulation of the word frequency `dictionary`
+
+        Note:
+            Not settable
+        """
+        return self._word_frequency
+
+    @property
+    def distance(self) -> int:
+        """int: The maximum edit distance to calculate
+
+        Note:
+            Valid values are 1 or 2; if an invalid value is passed, defaults to 2
+        """
+        return self._distance
+
+    @distance.setter
+    def distance(self, val: int) -> None:
+        """set the distance parameter"""
+        tmp = 2
+        try:
+            if 0 < int(val) <= 2:
+                tmp = val
+        except (ValueError, TypeError):
+            pass
+        self._distance = tmp
+
+    def split_words(self, text: KeyT) -> typing.Iterable[str]:
+        """Split text into individual `words` using either a simple whitespace
+        regex or the passed in tokenizer
+
+        Args:
+            text (str): The text to split into individual words
+        Returns:
+            list(str): A listing of all words in the provided text
+        """
+        text = ensure_unicode(text)
+        return self._tokenizer(text)
+
+    def export(self, filepath: PathOrStr, encoding: str = "utf-8", gzipped: bool = True) -> None:
+        """Export the word frequency list for import in the future
+
+        Args:
+           filepath (str): The filepath to the exported dictionary
+           encoding (str): The encoding of the resulting output
+           gzipped (bool): Whether to gzip the dictionary or not
+        """
+        data = json.dumps(self.word_frequency.dictionary, sort_keys=True)
+        write_file(filepath, encoding, gzipped, data)
+
+    def word_usage_frequency(self, word: KeyT, total_words: typing.Optional[int] = None) -> float:
+        """Calculate the frequency to the `word` provided as seen across the
+        entire dictionary
+
+        Args:
+            word (str): The word for which the word probability is calculated
+            total_words (int): The total number of words to use in the calculation
+            use the default for using the whole word frequency
+        Returns:
+            float: The probability that the word is the correct word
+        """
+        if not total_words:
+            total_words = self._word_frequency.total_words
+        word = ensure_unicode(word)
+        return self._word_frequency.dictionary[word] / total_words
+
+    def correction(self, word: KeyT) -> typing.Optional[str]:
+        """The most probable correct spelling for the word
+
+        Args:
+            word (str): The word to correct
+        Returns:
+            str: The most likely candidate or None if no correction is present
+        """
+        word = ensure_unicode(word)
+        candidates = self.candidates(word)
+        if not candidates:
+            return None
+        
+        word_no_accents = self._remove_diacritics(word)
+        diacritics_candidates = [c for c in candidates if self._remove_diacritics(c) == word_no_accents]
+        if diacritics_candidates:
+            return max(diacritics_candidates, key=self.__getitem__)
+        return max(candidates, key=self.__getitem__)
+
+    def candidates(self, word: KeyT) -> typing.Optional[typing.Set[str]]:
+        """Generate possible spelling corrections for the provided word up to
+        an edit distance of two, if and only when needed
+
+        Args:
+            word (str): The word for which to calculate candidate spellings
+        Returns:
+            set: The set of words that are possible candidates or None if there are no candidates
+        """
+        word = ensure_unicode(word)
+        if self.known([word]):
+            return {word}
+
+        if not self._check_if_should_check(word):
+            return {word}
+
+        res = list(self.edit_distance_1(word))
+        tmp = self.known(res)
+        if tmp:
+            return tmp
+        if self._distance == 2:
+            tmp = self.known(list(self.__edit_distance_alt(res)))
+            if tmp:
+                return tmp
+        return None
+
+    def known(self, words: typing.Iterable[KeyT]) -> typing.Set[str]:
+        """The subset of `words` that appear in the dictionary of words
+
+        Args:
+            words (list): List of words to determine which are in the corpus
+        Returns:
+            set: The set of those words from the input that are in the corpus
+        """
+        tmp_words = [ensure_unicode(w) for w in words]
+        tmp = [w if self._case_sensitive else w.lower() for w in tmp_words]
+        return {w for w in tmp if w in self._word_frequency.dictionary and self._check_if_should_check(w)}
+
+    def unknown(self, words: typing.Iterable[KeyT]) -> typing.Set[str]:
+        """The subset of `words` that do not appear in the dictionary
+
+        Args:
+            words (list): List of words to determine which are not in the corpus
+        Returns:
+            set: The set of those words from the input that are not in the corpus
+        """
+        tmp_words = [ensure_unicode(w) for w in words]
+        tmp = [w if self._case_sensitive else w.lower() for w in tmp_words if self._check_if_should_check(w)]
+        return {w for w in tmp if w not in self._word_frequency.dictionary}
+
+    def edit_distance_1(self, word: KeyT) -> typing.Set[str]:
+        """Generate all words that are one edit operation away from `word`,
+        using only characters present in the corpus
+
+        Args:
+            word (str): The input word to generate possible single-edit variations for
+        Returns:
+            set: A set of words that differ from the input by exactly one edit
+        """
+        tmp_word = ensure_unicode(word).lower() if not self._case_sensitive else ensure_unicode(word)
+        if self._check_if_should_check(tmp_word) is False:
+            return {tmp_word}
+        letters = self._word_frequency.letters
+        splits = [(tmp_word[:i], tmp_word[i:]) for i in range(len(tmp_word) + 1)]
+        deletes = [L + R[1:] for L, R in splits if R]
+        transposes = [L + R[1] + R[0] + R[2:] for L, R in splits if len(R) > 1]
+        replaces = [L + c + R[1:] for L, R in splits if R for c in letters]
+        inserts = [L + c + R for L, R in splits for c in letters]
+        return set(deletes + transposes + replaces + inserts)
+
+    def edit_distance_2(self, word: KeyT) -> typing.List[str]:
+        """Compute all strings that are two edits away from `word` using only
+        the letters in the corpus
+
+        Args:
+            word (str): The word for which to calculate the edit distance
+        Returns:
+            set: The set of strings that are edit distance two from the provided word
+        """
+        word = ensure_unicode(word).lower() if not self._case_sensitive else ensure_unicode(word)
+        return [e2 for e1 in self.edit_distance_1(word) for e2 in self.edit_distance_1(e1)]
+    
+    def check_text(self, text: str, api_key: str) -> bool:
+        """Checks the given text for spelling errors using the OpenAI API
+        
+        Args:
+            text (str): The text to be checked
+            api_key (str): The OpenAI API key to use for the request
+        
+        Returns:
+            bool: True if spelling errors are detected and the text must be rejected, False otherwise or if the API call/response fails
+        """
+        if not api_key:
+            raise ValueError("OpenAI API Key is required.")
+        
+        prompt = (
+            "Check this text carefully to review the spelling. "
+            "If there are spelling errors we must reject it. "
+            "Return your answer in this exact format with no additional commentary: {'reject': 'true' or 'false'}."
+        )
+
+        payload = {
+            "model": "gpt-4o",
+            "messages": [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": f"{prompt}\n\nText: {text}",
+                        }
+                    ],
+                }
+            ],
+            "max_tokens": 30,
+        }
+
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}",
+        }
+
+        try:
+            response = requests.post(
+                "https://api.openai.com/v1/chat/completions",
+                headers=headers,
+                json=payload,
+            )
+            response.raise_for_status()
+            must_reject = extract_json_content(response.text)
+            return bool(must_reject)
+        except Exception:
+            return False
+    
+    def check_image(self, image: typing.Union[str, bytes], api_key: str) -> bool:
+        """Checks the given image for spelling errors using the OpenAI API
+
+        Args:
+            image (str | os.PathLike | bytes | bytearray): The image to be checked, given as a file path (str or os.PathLike), or as bytes/bytearray
+            api_key (str): The OpenAI API key to use for the request
+        Returns:
+            bool: True if spelling errors are detected in the image and it must be rejected, False otherwise or if the API call/response fails
+        """
+        if not api_key:
+            raise ValueError("OpenAI API Key is required.")
+
+        if isinstance(image, (str, os.PathLike)):
+            base64_image = encode_image_from_path(str(image))
+        elif isinstance(image, (bytes, bytearray)):
+            base64_image = encode_image_from_bytes(bytes(image))
+
+        prompt = (
+            "Check this image carefully to review the spelling. "
+            "If there are spelling errors we must reject it. "
+            "Return your answer in this exact format with no additional commentary: {'reject': 'true' or 'false'}."
+        )
+
+        payload = {
+            "model": "gpt-4o",
+            "messages": [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": prompt,
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/webp;base64,{base64_image}",
+                                "detail": "low",
+                            },
+                        },
+                    ],
+                }
+            ],
+            "max_tokens": 30,
+        }
+
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}",
+        }
+
+        try:
+            response = requests.post(
+                "https://api.openai.com/v1/chat/completions",
+                headers=headers,
+                json=payload,
+            )
+            response.raise_for_status()
+            must_reject = extract_json_content(response.text)
+            return bool(must_reject)
+        except Exception as e:
+            return False
+
+    def __edit_distance_alt(self, words: typing.Iterable[KeyT]) -> typing.List[str]:
+        """Compute all strings that are 1 edits away from all the words using
+        only the letters in the corpus
+
+        Args:
+            words (list): The words for which to calculate the edit distance
+        Returns:
+            set: The set of strings that are edit distance two from the provided words
+        """
+        tmp_words = [ensure_unicode(w) for w in words]
+        tmp = [w if self._case_sensitive else w.lower() for w in tmp_words if self._check_if_should_check(w)]
+        return [e2 for e1 in tmp for e2 in self.known(self.edit_distance_1(e1))]
+
+    def _remove_diacritics(self, input_str: KeyT) -> str:
+        """Remove diacritics from the input string
+
+        Args:
+            input_str (str): The string from which to remove diacritics
+        Returns:
+            str: The string with diacritics removed
+        """
+        nfkd_form = unicodedata.normalize('NFKD', ensure_unicode(input_str))
+        return "".join([c for c in nfkd_form if not unicodedata.combining(c)])
+
+    def _check_if_should_check(self, word: str) -> bool:
+        if len(word) == 1 and word in string.punctuation:
+            return False
+        if len(word) > self._word_frequency.longest_word_length + 3:
+            return False
+        if word.lower() == "nan":
+            return True
+        try:
+            float(word)
+            return False
+        except ValueError:
+            pass
+        return True
+
+
+class WordFrequency:
+    """Store the `dictionary` as a word frequency list while allowing for
+    different methods to load the data and update over time
+    """
+
+    __slots__ = [
+        "_dictionary",
+        "_total_words",
+        "_unique_words",
+        "_letters",
+        "_tokenizer",
+        "_case_sensitive",
+        "_longest_word_length",
+    ]
+
+    def __init__(
+        self,
+        tokenizer: typing.Optional[typing.Callable[[str], typing.Iterable[str]]] = None,
+        case_sensitive: bool = False,
+    ) -> None:
+        self._dictionary: typing.Counter = Counter()
+        self._total_words = 0
+        self._unique_words = 0
+        self._letters: typing.Set[str] = set()
+        self._case_sensitive = case_sensitive
+        self._longest_word_length = 0
+
+        self._tokenizer = parse_into_words
+        if tokenizer is not None:
+            self._tokenizer = tokenizer
+
+    def __contains__(self, key: KeyT) -> bool:
+        """turn on contains"""
+        key = ensure_unicode(key)
+        key = key if self._case_sensitive else key.lower()
+        return key in self._dictionary
+
+    def __getitem__(self, key: KeyT) -> int:
+        """turn on getitem"""
+        key = ensure_unicode(key)
+        key = key if self._case_sensitive else key.lower()
+        return self._dictionary[key]
+
+    def __iter__(self) -> typing.Generator[str, None, None]:
+        """turn on iter support"""
+        yield from self._dictionary
+
+    def pop(self, key: KeyT, default: typing.Optional[int] = None) -> typing.Optional[int]:
+        """Remove the key and return the associated value or default if not
+        found
+
+        Args:
+            key (str): The key to remove
+            default (obj): The value to return if key is not present
+        Returns:
+            int | None: Returns the number of instances of key, or None if not in the dictionary
+        """
+        key = ensure_unicode(key)
+        return self._dictionary.pop(key if self._case_sensitive else key.lower(), default)
+
+    @property
+    def dictionary(self) -> typing.Dict[str, int]:
+        """Counter: A counting dictionary of all words in the corpus and the number
+        of times each has been seen
+
+        Note:
+            Not settable
+        """
+        return self._dictionary
+
+    @property
+    def total_words(self) -> int:
+        """int: The sum of all word occurrences in the word frequency dictionary
+
+        Note:
+            Not settable
+        """
+        return self._total_words
+
+    @property
+    def unique_words(self) -> int:
+        """int: The total number of unique words in the word frequency list
+
+        Note:
+            Not settable
+        """
+        return self._unique_words
+
+    @property
+    def letters(self) -> typing.Set[str]:
+        """set: The listing of all letters found within the corpus
+
+        Note:
+            Not settable
+        """
+        return self._letters
+
+    @property
+    def longest_word_length(self) -> int:
+        """int: The longest word length in the dictionary
+
+        Note:
+            Not settable
+        """
+        return self._longest_word_length
+
+    def tokenize(self, text: KeyT) -> typing.Iterator[str]:
+        """Tokenize the provided string object into individual words
+
+        Args:
+            text (str): The string object to tokenize
+        Yields:
+            str: The next `word` in the tokenized string
+        Note:
+            This is the same as the `split_words()` unless a tokenizer function was provided
+        """
+        tmp_text = ensure_unicode(text)
+        for word in self._tokenizer(tmp_text):
+            yield word if self._case_sensitive else word.lower()
+
+    def keys(self) -> typing.Iterator[str]:
+        """Iterator over the key of the dictionary
+
+        Yields:
+            str: The next key in the dictionary
+        Note:
+            This is the same as `words()`
+        """
+        yield from self._dictionary.keys()
+
+    def words(self) -> typing.Iterator[str]:
+        """Iterator over the words in the dictionary
+
+        Yields:
+            str: The next word in the dictionary
+        Note:
+            This is the same as `keys()`
+        """
+        yield from self._dictionary.keys()
+
+    def items(self) -> typing.Generator[typing.Tuple[str, int], None, None]:
+        """Iterator over the words in the dictionary
+
+        Yields:
+            str: The next word in the dictionary
+            int: The number of instances in the dictionary
+        Note:
+            This is the same as `dict.items()`
+        """
+        yield from self._dictionary.items()
+
+    def load_dictionary(self, filename: PathOrStr, encoding: str = "utf-8") -> None:
+        """Load in a pre-built word frequency list
+
+        Args:
+            filename (str): The filepath to the json (optionally gzipped) file to be loaded
+            encoding (str): The encoding of the dictionary
+        """
+        with load_file(filename, encoding) as data:
+            data = data if self._case_sensitive else data.lower()
+            self._dictionary.update(json.loads(data))
+            self._update_dictionary()
+
+    def load_json(self, data: typing.Dict[str, int]) -> None:
+        """Load in a pre-built word frequency list
+
+        Args:
+            data (dict): The dictionary to be loaded
+        """
+        self._dictionary.update(data)
+        self._update_dictionary()
+
+    def load_text_file(
+        self,
+        filename: PathOrStr,
+        encoding: str = "utf-8",
+        tokenizer: typing.Optional[typing.Callable[[str], typing.Iterable[str]]] = None,
+    ) -> None:
+        """Load in a text file from which to generate a word frequency list
+
+        Args:
+            filename (str): The filepath to the text file to be loaded
+            encoding (str): The encoding of the text file
+            tokenizer (function): The function to use to tokenize a string
+        """
+        with load_file(filename, encoding=encoding) as data:
+            self.load_text(data, tokenizer)
+
+    def load_text(
+        self,
+        text: KeyT,
+        tokenizer: typing.Optional[typing.Callable[[str], typing.Iterable[str]]] = None,
+    ) -> None:
+        """Load text from which to generate a word frequency list
+
+        Args:
+            text (str): The text to be loaded
+            tokenizer (function): The function to use to tokenize a string
+        """
+        text = ensure_unicode(text)
+        if tokenizer:
+            words = [x if self._case_sensitive else x.lower() for x in tokenizer(text)]
+        else:
+            words = self.tokenize(text)
+
+        self._dictionary.update(words)
+        self._update_dictionary()
+
+    def load_words(self, words: typing.Iterable[KeyT]) -> None:
+        """Load a list of words from which to generate a word frequency list
+
+        Args:
+            words (list): The list of words to be loaded
+        """
+        words = [ensure_unicode(w) for w in words]
+        self._dictionary.update([word if self._case_sensitive else word.lower() for word in words])
+        self._update_dictionary()
+
+    def add(self, word: KeyT, val: int = 1) -> None:
+        """Add a word to the word frequency list
+
+        Args:
+            word (str): The word to add
+            val (int): The number of times to insert the word
+        """
+        word = ensure_unicode(word)
+        self.load_json({word if self._case_sensitive else word.lower(): val})
+
+    def remove_words(self, words: typing.Iterable[KeyT]) -> None:
+        """Remove a list of words from the word frequency list
+
+        Args:
+            words (list): The list of words to remove
+        """
+        words = [ensure_unicode(w) for w in words]
+        for word in words:
+            self.pop(word)
+        self._update_dictionary()
+
+    def remove(self, word: KeyT) -> None:
+        """Remove a word from the word frequency list
+
+        Args:
+            word (str): The word to remove
+        """
+        self.pop(word)
+        self._update_dictionary()
+
+    def remove_by_threshold(self, threshold: int = 5) -> None:
+        """Remove all words at, or below, the provided threshold
+
+        Args:
+            threshold (int): The threshold at which a word is to be removed
+        """
+        to_remove = [k for k, v in self._dictionary.items() if v <= threshold]
+        self.remove_words(to_remove)
+
+    def _update_dictionary(self) -> None:
+        """Update the word frequency object"""
+        if not self._dictionary:
+            self._longest_word_length = 0
+            self._total_words = 0
+            self._unique_words = 0
+            self._letters = set()
+            return
+        keys = self._dictionary.keys()
+        self._longest_word_length = max(map(len, keys))
+        self._total_words = sum(self._dictionary.values())
+        self._unique_words = len(keys)
+        self._letters = set().union(*keys)

spellcheckerpy/info.py

@@ -0,0 +1,10 @@
+"""SpellChecker Information"""
+
+__author__ = "Tyler Barrus"
+__maintainer__ = "Tyler Barrus"
+__email__ = "barrust@gmail.com"
+__license__ = "MIT"
+__version__ = "1.1.0"
+__credits__ = ["Peter Norvig"]
+__url__ = "https://github.com/barrust/pyspellchecker"
+__bugtrack_url__ = f"{__url__}/issues"

spellcheckerpy/utils.py

@@ -0,0 +1,203 @@
+"""Additional utility functions"""
+
+import os
+import contextlib
+import functools
+import gzip
+import re
+import typing
+import warnings
+import base64
+import json
+import shutil
+from pathlib import Path
+
+from .info import __version__
+
+KeyT = typing.Union[str, bytes]
+PathOrStr = typing.Union[Path, str]
+
+
+def fail_after(version: str) -> typing.Callable:
+    """Decorator to add to tests to ensure that they fail if a deprecated
+    feature is not removed before the specified version
+
+    Args:
+        version (str): The version to check against
+    """
+    def decorator_wrapper(func):
+        @functools.wraps(func)
+        def test_inner(*args, **kwargs):
+            if [int(x) for x in version.split(".")] <= [int(x) for x in __version__.split(".")]:
+                msg = (
+                    f"The function {func.__name__} must be fully removed as it is deprecated"
+                    f" and must be removed by version {version}"
+                )
+                raise AssertionError(msg)
+            return func(*args, **kwargs)
+        return test_inner
+    return decorator_wrapper
+
+def deprecated(message: str = "") -> typing.Callable:
+    """A simplistic decorator to mark functions as deprecated. The function
+    will pass a message to the user on the first use of the function
+
+    Args:
+        message (str): The message to display if the function is deprecated
+    """
+    def decorator_wrapper(func):
+        @functools.wraps(func)
+        def function_wrapper(*args, **kwargs):
+            func_name = func.__name__
+            if func_name not in function_wrapper.deprecated_items:
+                msg = f"Function {func.__name__} is now deprecated! {message}"
+                warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
+                function_wrapper.deprecated_items.add(func_name)
+            return func(*args, **kwargs)
+        function_wrapper.deprecated_items = set()
+        return function_wrapper
+    return decorator_wrapper
+
+def ensure_unicode(value: KeyT, encoding: str = "utf-8") -> str:
+    """Simplify checking if passed in data are bytes or a string and decode
+    bytes into unicode
+
+    Args:
+        value (str): The input string (possibly bytes)
+        encoding (str): The encoding to use if input is bytes
+    Returns:
+        str: The encoded string
+    """
+    if isinstance(value, bytes):
+        return value.decode(encoding)
+    elif isinstance(value, list):
+        raise TypeError(f"The provided value {value} is not of type str or bytes")
+    return value
+
+@contextlib.contextmanager
+def __gzip_read(filename: PathOrStr, mode: str = "rb", encoding: str = "UTF-8") -> typing.Generator[KeyT, None, None]:
+    """Context manager to correctly handle the decoding of the output of the gzip file
+
+    Args:
+        filename (str): The filename to open
+        mode (str): The mode to read the data
+        encoding (str): The file encoding to use
+    Returns:
+        str: The string data from the gzip file read
+    """
+    with gzip.open(filename, mode=mode, encoding=encoding) as fobj:
+        yield fobj.read()
+
+@contextlib.contextmanager
+def load_file(filename: PathOrStr, encoding: str) -> typing.Generator[KeyT, None, None]:
+    """Context manager to handle opening a gzip or text file correctly and
+    reading all the data
+
+    Args:
+        filename (str): The filename to open
+        encoding (str): The file encoding to use
+    Returns:
+        str: The string data from the file read
+    """
+    if isinstance(filename, Path):
+        filename = str(filename)
+
+    if filename[-3:].lower() == ".gz":
+        with __gzip_read(filename, mode="rt", encoding=encoding) as data:
+            yield data
+    else:
+        with open(filename, encoding=encoding) as fobj:
+            yield fobj.read()
+
+def write_file(filepath: PathOrStr, encoding: str, gzipped: bool, data: str) -> None:
+    """Write the data to file either as a gzip file or text based on the
+    gzipped parameter
+
+    Args:
+        filepath (str): The filename to open
+        encoding (str): The file encoding to use
+        gzipped (bool): Whether the file should be gzipped or not
+        data (str): The data to be written out
+    """
+    if gzipped:
+        with gzip.open(filepath, "wt") as fobj:
+            fobj.write(data)
+    else:
+        with open(filepath, "w", encoding=encoding) as fobj:
+            fobj.write(data)
+
+def test_file(filepath: PathOrStr, encoding: str, index: str):
+    """Test and retrieve a section from a gzipped JSON file located in the resources directory.
+
+    Args:
+        filepath (str): The stem of the filename to open
+        encoding (str): The encoding to use when reading the file
+        index (str): The key to extract from dictionary
+    """
+    try:
+        filepath = f"{os.path.join(os.path.dirname(__file__), 'resources')}/{filepath}.json.gz"
+        with gzip.open(filepath, "rt", encoding=encoding) as f:
+            data = f.read()
+            data = json.loads(data)
+            data = data[index]
+            return data
+    except Exception as e:
+        print(f"An error occurred while reading gzip file: {e}")
+
+def parse_into_words(text: str) -> typing.Iterable[str]:
+    """Parse the text into words; currently removes punctuation except for
+    apostrophizes
+
+    Args:
+        text (str): The text to split into words
+    """
+    return re.findall(r"(\w[\w']*\w|\w)", text)
+
+def gzip_file(input_path: str, output_path: str) -> None:
+    """Compress a file using gzip
+
+    Args:
+        input_path (str): Path to the input file
+        output_path (str): Path where the gzipped file will be created
+    """
+    with open(input_path, 'rb') as f_in:
+        with gzip.open(output_path, 'wb') as f_out:
+            shutil.copyfileobj(f_in, f_out)
+    print(f"Gzipped file created at {output_path}")
+
+def encode_image_from_path(image_path: str) -> str:
+    """Encodes an image from a given file path as a base64 string
+
+    Args:
+        image_path (str): Path to the image file
+    Returns:
+        str: The base64-encoded string of the image contents
+    """
+    with open(image_path, "rb") as image_file:
+        return base64.b64encode(image_file.read()).decode("utf-8")
+
+def encode_image_from_bytes(image_bytes: bytes) -> str:
+    """Encodes image bytes as a base64 string
+
+    Args:
+        image_bytes (bytes): The image data as bytes
+    Returns:
+        str: Base64-encoded string of the image bytes
+    """
+    return base64.b64encode(image_bytes).decode("utf-8")
+
+def extract_json_content(response_text: str) -> typing.Optional[bool]:
+    """Extracts and interprets the 'reject' value from an OpenAI API response text JSON
+
+    Args:
+        response_text (str): The JSON response text from the OpenAI API
+    Returns:
+        Optional[bool]: True if the response indicates rejection ("reject": "true"), False if not rejected ("reject": "false"). Returns None if parsing fails
+    """
+    try:
+        response_json = json.loads(response_text)
+        content = response_json["choices"][0]["message"]["content"]
+        content_json = json.loads(content.replace("'", '"'))
+        return content_json.get("reject", "false").lower() == "true"
+    except (KeyError, IndexError, json.JSONDecodeError) as e:
+        return None

spellcheckerpy-1.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c)
+
+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.

spellcheckerpy-1.1.0.dist-info/METADATA

@@ -0,0 +1,34 @@
+Metadata-Version: 2.1
+Name: spellcheckerpy
+Version: 1.1.0
+Summary: Detect spelling errors in images and plain text using OpenAI Vision
+Author-email: Tyler Barrus <barrust@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/barrust/pyspellchecker
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31.0
+
+# spellcheckerpy
+
+Detect spelling errors in images and plain text using OpenAI Vision.
+
+
+## Usage
+
+```python
+
+from spellcheckerpy import SpellChecker
+
+spellchecker = SpellChecker()
+
+api_key = "YOUR_OPENAI_API_KEY"  # Replace with your OpenAI API key
+
+text = "I am a student."
+print(spellchecker.check_text(text, api_key))  # True = reject (spelling error). False = accept.
+
+image_path = "test.png"  # file path to an image or image bytes
+print(spellchecker.check_image(image_path, api_key))  # True = reject (spelling error). False = accept.
+
+```

spellcheckerpy-1.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+spellcheckerpy/__init__.py,sha256=QBtLViofx6CRTwH6q9N9NYbu7VADeBJkSLffUSBTeZM,277
+spellcheckerpy/core.py,sha256=cClPefkagFqbYLUJI6dkgl0DEdI9IHdYuc57iTIfy5M,25443
+spellcheckerpy/info.py,sha256=gbZejf8gz6zrZXQAstJ7HLIV5bRP_K2yi_Nn2-BekYQ,290
+spellcheckerpy/utils.py,sha256=0rpR8CfhOQJ04yjgYoQAx7lGKNpT1Ga_hjkiKv9o-SE,7234
+spellcheckerpy/resources/ar.json.gz,sha256=620Wb1XIxMEa6pO1x8lJBQP2f4K1mdC2cfz2yfMF_3M,714576
+spellcheckerpy/resources/de.json.gz,sha256=ecrNKij6bekInxL_rxHFNWNT6gih-V8Hghjx5ZR6lBQ,1075650
+spellcheckerpy/resources/en.json.gz,sha256=JHSkivhv2B3M6p7dC7ps023S7O3AriF878sjO7ooYTw,650750
+spellcheckerpy/resources/es.json.gz,sha256=YNJ_0V7iqZ5nn22lEdihQZQfJwU33uNESNHFEnkXUXE,354425
+spellcheckerpy/resources/eu.json.gz,sha256=XfVQapnGo9j2S7vlf45FT7bflBAHXvd2PYFjcDH6vzo,350357
+spellcheckerpy/resources/fa.json.gz,sha256=NbOPrSmIEsM2MEqSR2H2t4eJ6DMh2l3XHrup62T-_7M,88583
+spellcheckerpy/resources/fr.json.gz,sha256=BMJW9tBsTK3vZAtjAC4OOQAIJl440975cXLCktCaFB0,497432
+spellcheckerpy/resources/it.json.gz,sha256=TG4kWV5ZtPgC76LS4dJEw9nOZFrhsmItTcmLde0w_mE,465402
+spellcheckerpy/resources/lv.json.gz,sha256=nrltsXLlZj5Ta9DFXZZvIK5wvKXlUTIX69BfGKCvgoI,418819
+spellcheckerpy/resources/nl.json.gz,sha256=uhRB70F7TAped9GjIIZueWkkzZ2EOaQIURheWBKitsU,1328560
+spellcheckerpy/resources/pt.json.gz,sha256=buQc8cBxvh0FVkKxchST5iTuQNUyx3J0uIFCCnaiopQ,1261113
+spellcheckerpy/resources/ru.json.gz,sha256=wLUWMSkL0tG_Xo3ZAqZ-Zoqe974Am-ZXOV1BkBruf_M,107969
+spellcheckerpy-1.1.0.dist-info/LICENSE,sha256=Ccz49ErvRuftKuWMyju6gVrslVp5Po5OcxmEHLSXyxM,1072
+spellcheckerpy-1.1.0.dist-info/METADATA,sha256=4IiEi8odhQQ6J8FEb3qdMnWZSrCbGfxjADbbn9Dtxf4,959
+spellcheckerpy-1.1.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+spellcheckerpy-1.1.0.dist-info/top_level.txt,sha256=wlRGkCxqOqjKVkiwxNF0YhwMdlRxeteDlSwkJPRT7Z0,15
+spellcheckerpy-1.1.0.dist-info/RECORD,,

spellcheckerpy-1.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.45.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

spellcheckerpy-1.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+spellcheckerpy