Metadata-Version: 2.1
Name: re2shield
Version: 0.2.0
Summary: A Python library that provides a convenient interface for compiling and matching regular expression patterns using the re2 library.
Home-page: https://github.com/Npc-coder/re2shield
Author: mkCha
Author-email: dxsaq0@gmail.com
License: UNKNOWN
Description: # re2shield
        `re2shield` is a Python library that provides a shield for working with regular expressions using the `re2` module. 
        
        It allows you to compile and search for patterns in text using the powerful regular expression engine provided by `re2`.
        
        It allows you to hide the complexity of regular expressions and work with pattern identifiers instead.
        
        This project utilizes the `google/re2` library, which is licensed under the BSD 3-Clause License. Please refer to the [LICENSE](https://github.com/google/re2/blob/main/LICENSE) file of `google/re2` for more information.
        
        
        
        ## Installation
        Before installing `re2shield`, make sure that `re2` is installed on your system. You can install `re2` by following the instructions on the [google/re2](https://github.com/google/re2.git) GitHub repository.
        
        Alternatively, you can use the `re2-installer.sh` script located in the `package/installed` directory. This script automates the installation process for `re2` and its dependencies. Simply run the script using the following command:
        
        ```shell
        git clone https://github.com/Npc-coder/re2shield.git
        cd re2shield/installed
        sh re2-installer.sh
        ```
        
        You can install `re2shield` using pip:
        ```shell
        pip install re2shield
        ```
        or
        ```shell
        git clone https://github.com/Npc-coder/re2shield.git
        cd re2shield
        pip install .
        ```
        
        ## Updates
        ### Version 0.2.0
        - Bug Fix
            - Fixed a bug where pattern compile were not being overwrite.
        
        Please refer to the [Usage](#usage) section for examples of how to use these new features.
        
        ## Usage
        ### Importing the Library
        Here is a simple example demonstrating how to use re2shield:
        
        ```python
        import re2shield
        
        if __name__ == "__main__":
            db = re2shield.Database()
            print(db)
            # Load patterns from file
            try:
                db = re2shield.load('patterns.db')
                print(db)  # Prints the number of patterns in the database
            except FileNotFoundError:
                # If pattern file doesn't exist, compile the patterns
                patterns = [
                    (r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', 1),
                    (r'\b\d{3}[-.\s]??\d{3}[-.\s]??\d{4}\b', 2),
                    (r'\d+', 3)
                ]
        
                expressions, ids = zip(*patterns)
                db.compile(expressions=expressions, ids=ids, overwrite=False)
                print(db)  # Prints the number of patterns in the database and version
                db.dump('patterns.db')
        
            # Find patterns in text
            def match_handler(id, from_, to, flags, context):
                print(f"Match found for pattern {id} from {from_} to {to}: {context}")
        
            db.scan('test@ex12ample12.com', match_handler)
        ```
        In this example, we create a re2shield.Database object, compile a list of patterns with their corresponding identifiers, and then search for those patterns in the provided text. 
        
        The match_handler function is called for each match found, allowing you to process the matches as desired.
        
        ## Use Case
        One of the key advantages of re2shield is its ability to hide the actual regular expression patterns from users during distribution. By compiling the patterns with re2 and using pattern identifiers, you can distribute your code without exposing the underlying regular expression logic. This provides an additional layer of abstraction and enhances the security of your regular expression patterns.
        
        ## Features
        - Hide the complexity of regular expressions
        - Work with pattern identifiers instead of exposing the actual regular expression patterns
        - Compile patterns for efficient matching
        - Find all occurrences of patterns in text
        - Customize the handling of matches using callback functions
        
        ## License
        This project is licensed under the BSD 3-Clause License. See the [LICENSE](https://opensource.org/license/bsd-3-clause/) file for details.
        
Platform: UNKNOWN
Classifier: License :: OSI Approved :: BSD License
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3.8
Description-Content-Type: text/markdown
