PyAwaish 1.2

A Python package for building dynamic MySQL-powered web applications with template support

PyAwaish

PyAwaish is a Flask-based Python framework that simplifies the development of MySQL-powered web applications. It provides a streamlined interface for connecting to a MySQL database, rendering templates, and executing queries dynamically via RESTful APIs.

Features

• Dynamic MySQL Configuration: Configure MySQL database settings at runtime via a web interface.

• Template Rendering: Built-in support for rendering templates stored in the templates folder.

• Query Execution API: Execute MySQL queries dynamically through POST requests.

• CRUD Operations: Perform create, read, update, and delete operations programmatically.

• RESTful Design: Leverage Flask to expose endpoints for database interactions.

• Environment Configuration: Load sensitive credentials securely using environment variables.

Badges

Endpoints

1. `/`: Displays the MySQL configuration page.

2. `/home`: Displays the home page.

3. `/config_mysql`: Accepts a POST request to configure MySQL connection details dynamically.

4. `/execute_query`: Accepts a POST request to execute MySQL queries or perform operations (e.g., insert, delete, update).

Installation

1. Clone the repository:

   git clone https://github.com/abuawaish/CRUD_App.git
   cd CRUD_App

2. Install the required dependencies:

   pip install -r requirements.txt

3. Install the package:

   pip install PyAwaish

4. Set environment variables for database configuration:

   export MYSQL_HOST=localhost
   export MYSQL_USER=root
   export MYSQL_PASSWORD=your password
   export MYSQL_DB=mydatabase
   export SECRET_KEY=your_secret_key

Usage

Running the Application

To start the Mysql Web Application server, instantiate the MysqlApplication class and call its execute method. For example:

from PyAwaish.MysqlApplication import MysqlApplication

if __name__ == "__main__":
    # Initialize MysqlApplication with a secret key
    # Options:
    # 1. Pass the full path of the .env file: MysqlApplication(secret_key=r"full_path_to_env")
    # 2. Pass only the file name if it's in the working directory: MysqlApplication(secret_key=".env")
    # 3. Leave it empty: MysqlApplication()
    # 4. Use a custom string as the secret key:
    app = MysqlApplication(secret_key="your_secret_key")

    # Execute the application
    app.execute()

This will:

• Start a Flask server on http://0.0.0.0:5001.

• Serve endpoints for configuring and interacting with the MySQL database.

Initializing MysqlApplication with a Secret Key

The MysqlApplication class from PyAwaish.MysqlApplication requires a secret key for initialization. This secret key is used for configuration, authentication, or security purposes within the application. You can provide the secret key in different ways:

1. Using a `.env` file (Full Path)

   app = MysqlApplication(secret_key=r"C:\path\to\.env")

   • Provide the full path to a .env file that contains necessary environment variables.

2. Using a `.env` file (Relative Path)

   app = MysqlApplication(secret_key=".env")

   • If the .env file is located in the working directory, you can pass just the filename.

3. Without a Secret Key

   app = MysqlApplication()

   • If no secret key is provided, the application may use default settings.

4. Using a Custom Secret Key String

   app = MysqlApplication(secret_key="your_secret_key")

   • You can directly pass a custom string as the secret key.

Executing the Application

After initialization, you can execute the application using:

app.execute()

Configuring MySQL

1. Navigate to the root endpoint (http://localhost:5001/) to access the configuration page.

2. Enter the database details (host, username, password, database name) and click “Save”.

3. Upon successful configuration, you will be redirected to the home page.

Executing Queries

Use the /execute_query endpoint to run SQL queries or perform operations. Example request:

• POST Request Example:

  {
      "operation": "insert",
      "table_name": "users",
      "columns": "name, email",
      "values": "'John Doe', '[e-mail]'"
  }

• Supported Operations: - insert: Insert data into a table. - delete: Delete data from a table with a condition. - update: Update data in a table with a condition. - fetch_data: Fetch all data from a table. - show_tables: List all tables in the database.

Dependencies

The application requires the following dependencies (listed in requirements.txt):

• Flask: Web framework.

• Flask-MySQLdb: MySQL connector for Flask.

• python-dotenv: It loads environment variables from a .env file into os.environ.

To install them, run:

pip install -r requirements.txt

Environment Variables

• MYSQL_HOST: MySQL server hostname (default: localhost).

• MYSQL_USER: MySQL username (default: root).

• MYSQL_PASSWORD: MySQL password.

• MYSQL_DB: Default MySQL database name.

• SECRET_KEY: Flask secret key for session security.

Changelog

Refer to CHANGELOG.txt for the complete version history of the project.

License

This project is licensed under the MIT License. See LICENSE.txt for full details.

Contact

For questions or feedback, contact:

• Email: [e-mail]

• GitHub: https://github.com/abuawaish/CRUD_App

CHANGELOG

Version 1.1 (2025-01-29)

• Second release of PyAwaish.

• Added dynamic MySQL configuration through a web interface.

• Implemented template rendering for config_mysql.html and home.html.

• Developed /execute_query endpoint for executing MySQL queries.

• Supported CRUD operations: insert, delete, update, fetch_data.

• Enabled secure database connection using environment variables.

• Provided RESTFul API design for interaction with MySQL.

• Fixed the code markdown in readme.rst file

• Added warning messages

Version 1.2 (2025-01-30)

• Added support for .env file configuration.

• Improved error handling for missing secret keys.

• Optimized database connection initialization.

• Introduced custom secret key initialization.