Metadata-Version: 2.1
Name: encodify
Version: 1.0.2
Summary: A module for encoding and encrypting data.
Home-page: https://github.com/ishanoshada/encodify
Author: Ishan Oshada
Author-email: ic31908@gmail.com
License: UNKNOWN
Description: 
        
        # Encodify - Python Code Encoding Module
        
        `encodify` is a powerful Python module designed to provide a suite of advanced encoding techniques for Python scripts. These encoding methods encompass compression, base64 encoding, and XOR encryption, allowing users to obfuscate code for enhanced security or distribution.
        
        ## Table of Contents
        
        - [Installation](#installation)
        - [Usage](#usage)
          - [Importing the Module](#importing-the-module)
          - [Creating an Encoder Instance](#creating-an-encoder-instance)
          - [Encoding Specific Code](#encoding-specific-code)
          - [Generating Random Payload](#generating-random-payload)
          - [Generating Payload with a Specific Encoding Method](#generating-payload-with-a-specific-encoding-method)
          - [Additional Customization](#additional-customization)
        - [Advanced Techniques](#advanced-techniques)
        - [Examples](#examples)
        - [Best Practices and Considerations](#best-practices-and-considerations)
        - [License](#license)
        
        ## Installation
        
        To integrate `encodify` into your project, you can use `pip`:
        
        ```bash
        pip install encodify
        ```
        
        ## Usage
        
        ### Importing the Module
        
        To employ the functionalities of `encodify`, import the `Encodify` class from the module:
        
        ```python
        from encodify import Encodify
        ```
        
        ### Creating an Encoder Instance
        
        Instantiate the `Encodify` class to access a wide array of encoding techniques:
        
        ```python
        encoder = Encodify()
        ```
        
        ### Encoding Specific Code
        
        `encodify` excels at encoding specific Python code snippets. For instance, utilizing the `m1` encoding method:
        
        ```python
        code_to_encode = "print('Hello, World!')"
        encoded_code = encoder.m1(code_to_encode)
        ```
        
        ### Generating Random Payload
        
        For a dynamically selected encoding method, use the `random_payload` method. It produces a randomized payload, increasing the level of code obfuscation:
        
        ```python
        random_payload = encoder.random_payload("print('Hello, World!')", 2)
        ```
        
        ### Generating Payload with a Specific Encoding Method
        
        Tailor the encoding method to your requirements with the `gen_payload` method. Specify the method number to achieve the desired encoding:
        
        ```python
        # Choose the encoding method (e.g., m2)
        chosen_encoding_method = 2
        payload = encoder.gen_payload(chosen_encoding_method, "print('Hello, World!')")
        ```
        
        ### Additional Customization
        
        `encodify` offers extensive customization options. These include string replacements and appending/prepending custom code to the encoded output, allowing for fine-tuned control over the obfuscation process.
        
        ### Args for `gen_payload` Function
        
        The `gen_payload` function accepts the following arguments:
        
        - `choice` (int): The chosen encoding technique, determining the applied encoding method. Refer to the module documentation for a complete list of available choices.
        
        - `data` (str): The Python code to be encoded.
        
        - `line` (int, optional): The number of lines for line-based encoding (default is 2). This argument is applicable for specific encoding methods.
        
        - `options` (dict, optional): Further customization options (default is None). This may encompass string replacements or the addition of custom code.
        
        ### Available Encoding Methods
        
        ```plaintext
        +------+---------------------------------------------------+
        |  No  |           Encoding Method Description            |
        +------+---------------------------------------------------+
        |  1   |              m1: Gzip + Marshal + Base64          |
        |  2   |          m2: LZMA + Base64 + Marshal              |
        |  3   |         m3: LZMA + Base85 + Marshal               |
        |  4   |              m4: LZMA + Marshal                   |
        |  5   |          m5: Base64 + LZMA + Marshal              |
        |  6   |       m6: LZMA + Zlib + Marshal + Base64         |
        |  7   |     m7: LZMA + Gzip + Marshal + Base64           |
        |  8   |              m8: LZMA + Marshal                   |
        |  9   |       m9: Base64 + Gzip + Marshal + Base64        |
        |  10  |      m10: Base64 + Gzip + Marshal + LZMA          |
        |  11  |     m11: Base64 + Gzip + Marshal + Base64         |
        |  20  |     m20: Minify + Base64 + Gzip + Marshal         |
        |  23  |      l1: Line-based Encoding with Base85          |
        |  24  |  l2: Line-based Encoding with Base85 + LZMA       |
        |  25  |  l25: Line-based Encoding with Base64 + LZMA      |
        |  26  | l26: Line-based Encoding with Base64 + Codecs     |
        |  27  |  l27: Line-based Encoding with XOR Encryption     |
        |  28  | l28: Line-based Encoding with Base64 + XOR        |
        |  29  | l29: Line-based Encoding with Base64 + XOR        |
        |  30  | l30: Line-based Encoding with XOR + Codecs        |
        +------+---------------------------------------------------+
        ```
        
        
        ## Advanced Techniques
        
        `encodify` offers an array of advanced encoding techniques. These include line-based encoding, various combinations of compression, and XOR encryption. For in-depth guidance on these techniques, refer to the module's extensive documentation.
        
        ## Examples
        
        Explore some advanced examples showcasing the versatility of `encodify`:
        
        ```python
        from encodify import Encodify
        
        # Create an instance of Encodify
        encoder = Encodify()
        
        # Encode specific code using the m1 method
        code_to_encode = "print('Hello, World!')"
        encoded_code = encoder.m1(code_to_encode)
        
        # Generate a random payload with a random encoding method
        random_payload = encoder.random_payload("print('Hello, World!')", 2)
        
        # Generate a payload with a specific encoding method (e.g., m2)
        chosen_encoding_method = 2
        payload = encoder.gen_payload(chosen_encoding_method, "print('Hello, World!')")
        
        # Additional customization can be done using options
        ```
        
        ## Best Practices and Considerations
        
        1. **Use Responsibly**: This module is primarily intended for educational purposes. Use it responsibly and within the boundaries of applicable laws and ethical guidelines.
        
        2. **Testing and Verification**: Always test the encoded code to ensure it functions as expected.
        
        3. **Documentation**: Document the encoding method used and keep a record for future reference.
        
        ## License
        
        This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
        
        
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Description-Content-Type: text/markdown
