Documentation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5abf405b-58e9-4804-a59e-775cab26cd32",
   "metadata": {},
   "source": [
    "# Dev: Your AI-Powered Coding Assistant\n",
    "\n",
    "Dev is a multi-purpose tool designed to streamline your coding workflow and leverage the power of large language models to enhance your productivity. It automates several common tasks and provides valuable insights through AI capabilities, making your coding experience smoother and more efficient."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da583b55-a055-4294-9969-1d66f5867970",
   "metadata": {},
   "source": [
    "# Developer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a15f7b09-11a8-4ce9-b789-410475e9fc00",
   "metadata": {},
   "source": [
    "## Debugger\n",
    "Debugger provides a powerful tool for developers to streamline their debugging process. It is designed to automate the process of debugging code, making it more efficient and less time-consuming.\n",
    "\n",
    "**Key Features:**\n",
    "\n",
    "- Leverages Google's Gemini Pro language model for intelligent code analysis.\n",
    "- Automatically retrieves code from the clipboard for seamless debugging.\n",
    "- Generates potential fixes based on AI-powered insights.\n",
    "- Automatically apply fixes within the code editor.\n",
    "\n",
    "**Methods**:\n",
    "- `dest`: Select the destination of new code as per your need\n",
    "  * `dest=\"current\"`: for writing debugged code in your current file\n",
    "  * `dest=\"separate\"`: for writing debugged code in new brand new file **(Superior choice for serious, large, and complex codes)**\n",
    "\n",
    "\n",
    "**Key Components:**\n",
    "\n",
    "- **Debugger Class:** Encapsulates the debugging functionality.\n",
    "- **debugger() Method:**\n",
    "  - Retrieves code from the clipboard.\n",
    "  - Utilizes GoogleGenerativeAI to generate potential fixes.\n",
    "  - Applies fixes using PyAutoGUI.\n",
    "- **remove_first_and_last_lines() Function:** Cleans up AI-generated code formatting.\n",
    "\n",
    "## Usage\n",
    "\n",
    "1. **Import the Debugger Class:**\n",
    "  ```python\n",
    "  from Dev.Developer import Dev\n",
    "  ```\n",
    "\n",
    "2. **Create a Debugger Instance with Your API Key:**\n",
    "  ```python\n",
    "  debugger = Dev.Dev(your-key)\n",
    "  ```\n",
    "\n",
    "3. **Initiate Debugging:**\n",
    "  - **When an error occurs:**\n",
    "   ```python\n",
    "   debugger.Debugger(error) # Pass the error message as an argument\n",
    "   ```\n",
    "  - **To provide a specific prompt for guidance:**\n",
    "   ```python\n",
    "   debugger.Debugger(error, prompt=\"Add a comment explaining this line of code\")\n",
    "   ```\n",
    "\n",
    "## Sample code\n",
    "```python\n",
    "from Dev.Developer import Dev\n",
    "from key import key # please create a new python file \"key\" then paste your key inside their \n",
    "\n",
    "debugger = Dev.Dev(key) # you can directly paste your api key\n",
    "\n",
    "try:\n",
    "  def greet_user(name):\n",
    "    print(\"Hello, \" + uname + \"!\") # Typo: uname instead of name\n",
    "\n",
    "  greet_user(\"Alice\")\n",
    "\n",
    "except Exception as e:\n",
    "  debugger.Debugger(e)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2882874-09cc-4f27-96fc-9415238d464c",
   "metadata": {},
   "source": [
    "## README Generator\n",
    "The README Generator empowers you to effortlessly create detailed and informative READMEs for your projects. Forget spending time manually crafting these essential documents – this feature does the heavy lifting for you.\n",
    "\n",
    "**Usage:**\n",
    "\n",
    "1: Import the Dev Class:\n",
    "\n",
    "```Python\n",
    "from Dev.Developer import Dev\n",
    "```\n",
    "\n",
    "```Python\n",
    "dev = Dev(your-key)\n",
    "```\n",
    "\n",
    "```Python\n",
    "dev.generate_readme()\n",
    "```\n",
    "\n",
    "```Python\n",
    "from Dev.Developer import Dev\n",
    "from key import key\n",
    "\n",
    "dev = Dev.Dev(key)\n",
    "\n",
    "dev.generate_readme()\n",
    "\n",
    "print(\"Your README is generated! Check out the 'README.md' file.\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ced540c1-9ceb-4f73-a537-3180aeae0fcc",
   "metadata": {},
   "source": [
    "## Upload Git:\n",
    "\n",
    "This functionality simplifies Git repository management by automating commands\n",
    "\n",
    "**Usage:**\n",
    "\n",
    "1: Import the Dev Class:\n",
    "\n",
    "```Python\n",
    "from Dev.Developer import Dev\n",
    "```\n",
    "\n",
    "```Python\n",
    "dev = Dev(your-key)\n",
    "```\n",
    "\n",
    "2: Upload your code to a new repository:\n",
    "\n",
    "```Python\n",
    "dev.upload_git(\"your-git-username\", \"your-repository-name\")\n",
    "```\n",
    "\n",
    "**Sample Code:**\n",
    "\n",
    "```Python\n",
    "from Dev.Developer import Dev\n",
    "from key import key\n",
    "\n",
    "dev = Dev.Dev(key)\n",
    "\n",
    "dev.upload_git(\"Bard-Dev\", \"my-awesome-project\")\n",
    "\n",
    "print(\"Your code is uploaded to your GitHub repository!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96081095-9212-49d4-918b-767fc509fac2",
   "metadata": {},
   "source": [
    "## Rename GitHub Repo:\n",
    "\n",
    "This feature allows you to easily rename your existing GitHub repository directly from your code editor.\n",
    "\n",
    "**Usage:**\n",
    "\n",
    "1: Import the Dev Class:\n",
    "\n",
    "```Python\n",
    "from Dev.Developer import Dev\n",
    "```\n",
    "\n",
    "2: Create a Dev Instance:\n",
    "\n",
    "```Python\n",
    "dev = Dev.Dev(your-key)\n",
    "```\n",
    "\n",
    "3: Rename your repository:\n",
    "\n",
    "```Python\n",
    "dev.rename_github_repo(\"old-repo-name\", \"new-repo-name\")\n",
    "```\n",
    "\n",
    "**Sample Code:**\n",
    "\n",
    "```Python\n",
    "from Dev.Developer import Dev\n",
    "from key import key\n",
    "\n",
    "dev = Dev.Dev(key)\n",
    "\n",
    "dev.rename_github_repo(\"my-old-repo\", \"my-new-repo)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fd4a683-3b9f-495b-a2d5-cbc83546f411",
   "metadata": {},
   "source": [
    "## Generate:\n",
    "\n",
    "This functionality leverages the language model to generate code based on your instructions or prompts.\n",
    "\n",
    "**Methods**:\n",
    "- `dest`: Select the destination of new code as per your need\n",
    "  * `dest=\"current\"`: for writing generated code in your current file\n",
    "  * `dest=\"separate\"`: for writing generated code in new brand new file **(Superior choice for serious, large, and complex codes)**\n",
    "\n",
    "**Usage:**\n",
    "\n",
    "1: Import the Dev Class:\n",
    "\n",
    "```Python\n",
    "from Dev.Developer import Dev\n",
    "```\n",
    "\n",
    "2: reate a Dev Instance:\n",
    "\n",
    "```Python\n",
    "dev = Dev.Dev(your-key)\n",
    "```\n",
    "\n",
    "3: Generate code based on a prompt:\n",
    "\n",
    "```Python\n",
    "dev.generate(\"create a python code to print 0 to 100\")\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83b89894-320d-4ae1-8411-082f63ae330f",
   "metadata": {},
   "source": [
    "## Review\n",
    "The Review function provides valuable insights into your code, helping you refine its quality and identify potential areas for improvement.\n",
    "\n",
    "**Usage:**\n",
    "\n",
    "1: Import the Dev Class:\n",
    "\n",
    "```Python\n",
    "from Dev.Developer import Dev\n",
    "```\n",
    "\n",
    "2: Create a Dev Instance:\n",
    "\n",
    "```Python\n",
    "dev = Dev(your-key)\n",
    "```\n",
    "\n",
    "3: Run the Review:\n",
    "\n",
    "```Python\n",
    "dev.review()\n",
    "```\n",
    "\n",
    "**Output:**\n",
    "\n",
    "The review report will be saved to a file named \"review.txt\". This file will contain detailed feedback on your code, including:\n",
    "\n",
    "- Potential improvements: Suggestions for optimizing code structure, performance, and readability.\n",
    "- Alternative approaches: Different ways to achieve the same functionality, potentially offering advantages in specific situations.\n",
    "- Warnings and errors: Identification of potential bugs, code smells, and best practices violations.\n",
    "- Overall comments: General observations and recommendations for enhancing your code.\n",
    "\n",
    "**Sample Code:**\n",
    "\n",
    "```Python\n",
    "from Dev.Developer import Dev\n",
    "from key import key\n",
    "\n",
    "dev = Dev.Dev(key)\n",
    "\n",
    "dev.review()\n",
    "\n",
    "print(\"Your code review is saved in 'review.txt'!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d4df17f-fc3c-48ba-bb88-f7cdcd2d958b",
   "metadata": {},
   "source": [
    "## Generate Requirements Files:\n",
    "\n",
    "**Key Features:**\n",
    "\n",
    "- Automatically analyzes your code to identify required dependencies.\n",
    "- Creates a comprehensive requirements.txt file listing those dependencies.\n",
    "- Ensures compatibility and reproducibility for project setup.\n",
    "\n",
    "**Usage:**\n",
    "\n",
    "```Python\n",
    "dev.generate_requirements()\n",
    "```\n",
    "\n",
    "**Output:**\n",
    "A requirements.txt file is generated in your project directory, ready for use."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "581fc9d8-d3a6-4ce3-a59c-4f2dc7ed5db1",
   "metadata": {},
   "source": [
    "## Generate Setup Files:\n",
    "\n",
    "**Key Features:**\n",
    "\n",
    "- Automates the creation of setup.py files for Python projects.\n",
    "- Streamlines the packaging and distribution process.\n",
    "- Simplifies installation for others who want to use your project.\n",
    "\n",
    "**Usage:**\n",
    "\n",
    "```Python\n",
    "dev.generate_setup()\n",
    "```\n",
    "\n",
    "**Output:**\n",
    "A setup.py file is generated in your project directory, ready for deployment."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7a02e04-a66f-495b-a60a-968be44ef2bb",
   "metadata": {},
   "source": [
    "## Explain:\n",
    "\n",
    "**Key Features:**\n",
    "- Code Analysis: Thoroughly examines your code to grasp its purpose and functionality.\n",
    "- Customized Explanations: Provides explanations in either detail or summary mode, adapting to your specific needs.\n",
    "- Clear Documentation: Generates a text file containing the explanation, allowing for easy reference and sharing.\n",
    "\n",
    "**Usage:**\n",
    "\n",
    "1: Import the Dev Class:\n",
    "\n",
    "```Python\n",
    "from Dev.Developer import Dev\n",
    "```\n",
    "\n",
    "2: Create a Dev Instance:\n",
    "\n",
    "```Python\n",
    "dev = Dev.Dev(your-key)\n",
    "```\n",
    "\n",
    "```Python\n",
    "dev.Explain(mode=\"detail\")  # For a detailed explanation\n",
    "dev.Explain(mode=\"summary\")  # For a concise summary\n",
    "```\n",
    "\n",
    "**Output:**\n",
    "\n",
    "A new explanation.txt file containing the generated explanation will be created.\n",
    "Open the file to delve into the depths of your code's functionality."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce1e95a9-a311-4018-8d3d-5850004db08a",
   "metadata": {},
   "source": [
    "## Generate UI:\n",
    "\n",
    "**Key Features:**\n",
    "- Automatic Code Analysis: Intelligently examines your backend code to understand its structure and logic.\n",
    "- UI Generation with CSS: Seamlessly produces a corresponding HTML file with integrated CSS, ensuring a visually appealing and well-formatted interface.\n",
    "- Backend Integration: Cleverly connects the generated UI with your backend code, ensuring seamless communication and functionality.\n",
    "\n",
    "**Usage:**\n",
    "\n",
    "1: Import the Dev Class:\n",
    "\n",
    "```Python\n",
    "from Dev.Developer import Dev\n",
    "```\n",
    "\n",
    "2: Create a Dev Instance:\n",
    "\n",
    "```Python\n",
    "dev = Dev.Dev(your-key)\n",
    "```\n",
    "\n",
    "3: Generate the UI:\n",
    "\n",
    "```Python\n",
    "dev.Generate_UI()\n",
    "```\n",
    "\n",
    "**Output:**\n",
    "\n",
    "A new index.html file containing the generated UI with inline CSS will be created.\n",
    "The file will automatically open in your default browser for immediate preview.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfff106d-bd77-44ab-a392-6b7b11df9d4f",
   "metadata": {},
   "source": [
    "## Modify:\n",
    "This functionality empowers you to directly modify your code within your code editor, leveraging the power of large language models for enhanced efficiency and quality.\n",
    "\n",
    "**Key Features:**\n",
    "\n",
    "- Prompted Code Modification: Provide specific instructions or ask questions about your code, and the AI will suggest modifications directly within your editor.\n",
    "- Code Understanding: The language model analyzes the context and structure of your code, ensuring modifications are relevant and maintain functionality.\n",
    "- Automatic Formatting: Preserves the original code formatting while applying changes, maintaining code readability.\n",
    "\n",
    "**How it Works:**\n",
    "\n",
    "- Provide a prompt: Type your desired changes or questions in the Dev interface.\n",
    "- AI analyzes and suggests: Dev utilizes Google's Gemini Pro language model to generate modifications.\n",
    "- Code is updated: The modified code is automatically inserted into your editor, replacing the original selection.\n",
    "- Formatting retained: The code retains its original formatting for a seamless transition.\n",
    "\n",
    "**Benefits:**\n",
    "\n",
    "- Save time: Quickly iterate and experiment with code modifications without manual editing.\n",
    "- Improve code quality: Gain valuable insights and suggestions for cleaner, more efficient code.\n",
    "- Boost creativity: Explore new possibilities and approaches with AI-powered guidance.\n",
    "\n",
    "**Methods**:\n",
    "- `dest`: Select the destination of new code as per your need\n",
    "  * `dest=\"current\"`: for writing modified code in your current file\n",
    "  * `dest=\"separate\"`: for writing modified code in new brand new file **(Superior choice for serious, large, and complex codes)**\n",
    "\n",
    "**Example Usage:**\n",
    "\n",
    "Prompt: \"Make this function more efficient by using a list comprehension.\"\n",
    "\n",
    "**Original Code:**\n",
    "```python\n",
    "def calculate_sum(numbers):\n",
    "  total = 0\n",
    "  for num in numbers:\n",
    "    total += num\n",
    "  return total\n",
    "```\n",
    "\n",
    "**Modified code**\n",
    "```python\n",
    "def calculate_sum(numbers):\n",
    "  return sum(numbers)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "caf20f80-2251-4b0d-b544-c5a7dea610bb",
   "metadata": {},
   "source": [
    "## Setup Flask App\n",
    "\n",
    "**Key Features:**\n",
    "\n",
    "- Generates essential Flask application code, including routing and a basic response.\n",
    "- Creates necessary directories ```static``` and ```templates``` for further customization.\n",
    "- Writes the Flask app code to a designated Python file ```app.py```\n",
    "- Creates a default HTML template file ```index.html``` with a simple structure.\n",
    "\n",
    "**Benefits:**\n",
    "\n",
    "- Quickstart Development: Get your Flask project up and running in no time, focusing on core functionalities instead of boilerplate code.\n",
    "- Organized Structure: Ensures proper directory and file organization for maintainable and scalable projects.\n",
    "- Customization Ready: Provides a solid foundation for further development and personalization of your Flask application.\n",
    "\n",
    "  **Usage:**\n",
    "\n",
    "  1: Import the Dev Class:\n",
    "  ```python\n",
    "  from Dev.Developer import Dev\n",
    "  ```\n",
    "\n",
    "  2: Create a Dev Instance:\n",
    "  ```python\n",
    "  dev = Dev.Dev(your_api_key)\n",
    "  ```\n",
    "\n",
    "  3: Set up your Flask app:\n",
    "  ```python\n",
    "  dev.setup_flask_app()\n",
    "  ```\n",
    "\n",
    "  **Output:**\n",
    "  The function will create the necessary files and directories in your current working directory, allowing you to start building your Flask application right away."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cabd2f63-25d3-43d5-9861-02a863dcb946",
   "metadata": {},
   "source": [
    "# Managers\n",
    "  \n",
    "# User_manager\n",
    "\n",
    "**Introduction:**\n",
    "\n",
    "This feature simplifies interacting with MongoDB databases, providing convenient methods for creating, reading, updating, and deleting data. With DB_manager, you can manage your MongoDB operations efficiently and effortlessly.\n",
    "\n",
    "**Key Features**\n",
    "- Connect to Databases: Establish connections using connection strings.\n",
    "- CRUD Operations:\n",
    "  * Create: Insert single or multiple documents.\n",
    "  * Read: Find documents based on queries or retrieve all documents.\n",
    "  * Update: Modify documents matching specific criteria.\n",
    "  * Delete: Remove documents matching a query.\n",
    "- Bulk Operations: Perform efficient insertions, updates, and deletions on multiple documents.\n",
    "- Database and Collection Management: Create, access, and delete databases and collections.\n",
    "\n",
    "**Key Components:**\n",
    "- connect() Method: Establishes a connection to the specified database.\n",
    "- create() Method: Inserts a single document into the collection.\n",
    "- read() Method: Retrieves documents based on a query or all documents.\n",
    "- update() Method: Updates documents matching a specific query.\n",
    "- delete() Method: Removes documents matching a specific query.\n",
    "- create_bulk() Method: Inserts multiple documents efficiently.\n",
    "- update_bulk() Method: Updates multiple documents matching a query.\n",
    "- delete_bulk() Method: Deletes multiple documents matching a query.\n",
    "- create_database() Method: Creates a new database and collection.\n",
    "- create_collection() Method: Creates a new collection within an existing database.\n",
    "- delete_collection() Method: Removes a collection from the database.\n",
    "\n",
    "## Usage:\n",
    "\n",
    "1: Import the User_manager Class:\n",
    "```python\n",
    "from Dev.Managers import User_manager\n",
    "```\n",
    "\n",
    "2: Create an instance:\n",
    "```python\n",
    "db_manager = User_manager.DB_manager(\"mongodb://localhost:27017\", \"Your Database name\", \"Your collection name\")\n",
    "```\n",
    "\n",
    "3: Interact with your database:\n",
    "```python\n",
    "# Insert a document\n",
    "data = {\"name\": \"John Doe\", \"age\": 30}\n",
    "db_manager.create(data)\n",
    "\n",
    "# Find all documents with age greater than 25\n",
    "results = db_manager.read({\"age\": 30})\n",
    "\n",
    "# Update documents with age 30 and set their city to \"New York\"\n",
    "db_manager.update({\"age\": 30}, {\"city\": \"New York\"}}) # Dev can handle dollar complication, you just need to give new data\n",
    "\n",
    "# Delete all documents with age 30\n",
    "db_manager.delete({\"age\": 30})\n",
    "\n",
    "# Create a new database and collection\n",
    "db_manager.create_database(\"my_new_database\", \"my_new_collection\")\n",
    "\n",
    "# Insert multiple documents at once\n",
    "documents = [{\"name\": \"Alice\"}, {\"name\": \"Bob\"}]\n",
    "db_manager.create_bulk(documents)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf265f28-058f-4198-81bd-e3752537fc5a",
   "metadata": {},
   "source": [
    "# Auth_manager\n",
    "\n",
    "**Introduction:**\n",
    "\n",
    "Auth_manager empowers you to easily implement user authentication and management functionalities in your Python applications. With its built-in security features, Auth_manager streamlines user registration, login, and profile management.\n",
    "\n",
    "**Key Features**\n",
    "- User Registration: Create new user accounts with usernames and passwords.\n",
    "- User Deletion: Remove user accounts from the system.\n",
    "- Password Updates: Allow users to change their passwords securely.\n",
    "- Authentication: Verify user credentials for secure access control.\n",
    "- User Details Retrieval: Access specific user information for various purposes.\n",
    "\n",
    "**Key Components:**\n",
    "- register_user() Method: Add a new user to the system.\n",
    "- delete_user() Method: Remove a user from the database.\n",
    "- update_user() Method: Enable users to update their passwords.\n",
    "- authenticate_user() Method: Verify user credentials for login attempts.\n",
    "- fetch_user_details() Method: Retrieve specific information about a user.\n",
    "\n",
    "## Usage:\n",
    "\n",
    "1: Import the DevAuth Class:\n",
    " ```python\n",
    "from Dev.Managers import Auth_manager\n",
    "```\n",
    "\n",
    "2: Create an instance:\n",
    "```python\n",
    "auth_manager = Auth_manager.DevAuth(\"mongodb://localhost:27017\", \"Your Database name\", \"Your collection name\")\n",
    "```\n",
    "\n",
    "3: Manage user accounts:\n",
    "```python\n",
    "# Register a new user\n",
    "auth_manager.register_user(\"john_doe\", \"password123\")\n",
    "\n",
    "# Explore more!\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df8eacfd-2142-4eb7-aa20-8e3d44efb55a",
   "metadata": {},
   "source": [
    "# Templates\n",
    "# Web\n",
    "\n",
    "## Introduction\n",
    "\n",
    "**Dev's Templates** provides a streamlined starting point for Python developers to create their websites using pre-built templates. Whether you're a beginner unsure of where to begin or an experienced developer seeking a quick setup, Dev's Templates offers a beautiful dashboard and various templates to kickstart your web development journey.\n",
    "\n",
    "Key features include:\n",
    "\n",
    "- **Built-in Templates**: Dev's Templates includes ready-to-use templates for landing pages, navigation bars, and more.\n",
    "- **Dashboard Options**: Choose from different dashboards tailored for various website types:\n",
    "    - General websites\n",
    "    - E-commerce websites\n",
    "    - Blog websites\n",
    "    - Portfolio websites\n",
    "- **Login and Signup Pages**: Dev also offers built-in login and signup pages for seamless user authentication.\n",
    "\n",
    "Get started with Dev's Templates and accelerate your web development process! 🚀\n",
    "\n",
    "## Components\n",
    "- ```fetch_configs()```: Fetch all the available html templates\n",
    "- ```get_configs()``` : Import html template from available templates\n",
    "- ```setup_configs()``` : Setup a basic website using flask and general Template of Dev\n",
    "\n",
    "\n",
    "\n",
    "## Quick start\n",
    "### Main.py\n",
    "\n",
    "Create a python file ```main.py``` and run given code, make sure that there is no ```app.py``` file in same directory where you are running your ```main.py```. Dev automatically setup everything like project structure and ```app.py```. After running ```main.py``` just delete it, and run your ```app.py```. **And congratulations your website is generated in just 2 lines of code!** 🎉\n",
    "\n",
    "```python\n",
    "import Dev.Templates.setup_templates as sd\n",
    "\n",
    "sd.setup_configs()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "209c426e-878f-4ae6-b325-dfb0458c057d",
   "metadata": {},
   "source": [
    "# Socket\n",
    "\n",
    "Socket Functionality: The star of this release, the socket functionality, is an inbuilt feature that simplifies socket connections using just one line of code in Dev. Whether you’re building real-time applications, chat systems, or multiplayer games, this feature streamlines communication between clients and servers.\n",
    "  \n",
    "## Socket Functionality Highlights\n",
    "  \n",
    "- Effortless Connectivity: Establish socket connections effortlessly. Say goodbye to complex setup procedures; now, it’s as simple as a single line of code.\n",
    "  \n",
    "- Streamlined Communication: Communicate efficiently between clients and servers. Whether you’re sending messages, data streams, or notifications, the socket functionality ensures smooth communication.\n",
    "  \n",
    "- Minimal Code: Achieve powerful socket functionality with concise code. We’ve abstracted away the complexities, allowing you to focus on your application logic.\n",
    "\n",
    "## Quick Start\n",
    "\n",
    "### Setup Connection\n",
    "\n",
    "```python\n",
    "from Dev.Templates.Socket import setup_connection\n",
    "\n",
    "setup_connection.setup_socket_files()\n",
    "```\n",
    "\n",
    "### Setup Group Connection\n",
    "\n",
    "```python\n",
    "from Dev.Templates.Socket import setup_group_connection\n",
    "\n",
    "setup_group_connection.setup_group_connection()\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}