chefmate 1.0.0__py3-none-any.whl

chefmate/cli.py

@@ -0,0 +1,275 @@
+# cli.py
+import os
+import sys
+import click
+import time
+import platform
+import colorama
+import threading
+from colorama import Fore
+from chefmate.chefmate_core import ChefMate
+from InquirerPy import inquirer
+from InquirerPy.base.control import Choice
+from rich import box
+from rich.text import Text
+from rich.table import Table
+from rich.console import Console
+
+colorama.init(autoreset=True)
+console = Console()
+
+def hide_cursor():
+    sys.stdout.write("\033[?25l")
+    sys.stdout.flush()
+
+def show_cursor():
+    sys.stdout.write("\033[?25h")
+    sys.stdout.flush()
+
+def loading_animation(stop_event):
+    while not stop_event.is_set():
+        for i in range(4):
+            if stop_event.is_set():
+                break
+            sys.stdout.write(f"\r{Fore.YELLOW} Loading {'.' * i}   ")
+            sys.stdout.flush()
+            time.sleep(0.25)
+
+def clear_terminal():
+    """Clears the terminal screen based on the OS"""
+    os.system('cls' if platform.system() == 'Windows' else 'clear')
+    print(f"{Fore.GREEN} Terminal cleared successfully! \u2714\n")
+
+@click.group()
+def cli():
+    """ChefMate - CodeChef Automation Tool"""
+    pass
+
+@cli.command()
+def setup():
+    """Configure ChefMate settings"""
+    cm = ChefMate()
+    cm.setup()
+
+@cli.command()
+def login():
+    """Login to CodeChef"""
+    cm = ChefMate()
+    if cm.initialize():
+        cm.login()
+    else:
+        click.echo(f"{Fore.RED} Failed to initialize browser.")
+
+@cli.command()
+def logout():
+    """Logout from CodeChef"""
+    cm = ChefMate()
+    if cm.initialize():
+        cm.logout()
+    else:
+        click.echo(f"{Fore.RED} Failed to initialize browser.")
+
+@cli.command()
+@click.option('--problem', '-p', type=int, help='Problem number to check')
+def check(problem):
+    """Check sample test cases for a problem"""
+    cm = ChefMate()
+    if cm.initialize() and cm.login():
+        if cm.open_contest():
+            cm.demo_cases_check(problem)
+    else:
+        click.echo(f"{Fore.RED} Failed to initialize session.")
+
+@cli.command()
+@click.option('--problem', '-p', type=int, help='Problem number to submit')
+def submit(problem):
+    """Submit solution for a problem"""
+    cm = ChefMate()
+    if cm.initialize() and cm.login():
+        if cm.open_contest():
+            cm.submit_solution(problem)
+    else:
+        click.echo(f"{Fore.RED} Failed to initialize session.")
+
+@cli.command()
+def contest():
+    """Open a contest and load problems"""
+    cm = ChefMate()
+    if cm.initialize() and cm.login():
+        cm.open_contest()
+    else:
+        click.echo(f"{Fore.RED} Failed to initialize session.")
+# -------------------- Interactive Mode ------------------
+@cli.command()
+def interactive():
+    """Run ChefMate in interactive mode"""
+    cm = ChefMate()
+    
+    cm.display_logo()
+    
+    click.echo("\n" + f"{Fore.CYAN}=" * 50)
+    click.echo(f"{Fore.CYAN}ChefMate Interactive Mode")
+    click.echo(f"{Fore.CYAN}=" * 50)
+
+    try:
+        hide_cursor()
+        stop_event = threading.Event()
+        loading_thread = threading.Thread(target=loading_animation, args=(stop_event,))
+        loading_thread.start()
+
+        first_login = False
+        if not cm.config.get("username", "") or not cm.config.get("password", "") or not cm.config.get("solution_path", ""):
+            stop_event.set()
+            loading_thread.join()
+            sys.stdout.write("\r")
+            sys.stdout.flush()
+            print(f"{Fore.CYAN} We need to configure first.")
+            first_login = True
+            cm.setup()
+
+        if not cm.initialize():
+            stop_event.set()
+            loading_thread.join()
+            sys.stdout.write("\r")
+            sys.stdout.flush()
+            click.echo(f"{Fore.RED} Failed to initialize browser.")
+            cm.quit()
+            return
+        
+        stop_event.set()
+        loading_thread.join()
+        sys.stdout.write("\r")
+        sys.stdout.flush()
+    finally: show_cursor()
+
+    quest_list = [
+        Choice(value="_login", name="Login"),
+        Choice(value="_logout", name="Logout"),
+        Choice(value="_exit", name="Exit"),
+        Choice(value="_contest_ini", name="Open Contest"),
+        Choice(value="_solve", name="Solve Problems"),
+        Choice(value="_demo", name="Check Demo test cases"),
+        Choice(value="_submit", name="Submit Solution"),
+        Choice(value="_reconfig", name="Re-configure ChefMate"),
+        Choice(value="_log_and_ex", name="Logout and Exit"),
+        Choice(value="_clear", name="Clear Terminal"),
+    ]
+
+    current_choice = "_login"  # Set a default starting choice
+
+    while True:
+        choice = inquirer.select(
+            message="Select an option: ",
+            choices=quest_list,
+            default=current_choice,  # Use the stored current choice
+            qmark="",            # Remove the default [?]
+            pointer=">",        # Custom arrow pointer
+            instruction="(Use arrow keys to navigate)"
+        ).execute()
+        
+        # Update the current choice for next iteration
+        current_choice = choice
+        
+        print("\033[F\033[2K", end="")
+        selected_name = next((c.name for c in quest_list if c.value == choice), choice)
+        table = Table(show_header=False, box=box.ROUNDED, border_style='green')
+
+        # Create a Text object with styling for selected name
+        styled_text = Text("You Selected: ")
+        styled_text.append(selected_name, style="cyan")
+        
+        table.add_row(styled_text)
+        console.print(table)
+
+        if choice == '_login': 
+            if first_login:
+                cm.login(first_login=True)
+            else: cm.login()
+        elif choice == '_logout': cm.logout()
+        elif choice == '_config': cm.setup()
+        elif choice == '_clear': clear_terminal()
+        elif choice == '_contest_ini': 
+            quest_list.pop(3)
+            quest_list.insert(3, Choice(value="_track_problelm", name="Problem Tracker"))
+            quest_list.insert(4, Choice(value="_close_curr_cont", name="Close Current Contest"))
+            quest_list.insert(5, Choice(value="_contest_again", name="Open another Contest"))
+            cm.open_contest() 
+        elif choice == '_solve': cm.solve()
+        elif choice == '_reconfig': cm.reconfig()
+        elif choice == '_submit': cm.submit_solution()
+        elif choice == '_demo': cm.demo_cases_check()
+        elif choice == '_exit': 
+            cm.quit()
+            break
+        elif choice == '_log_and_ex': 
+            cm.logout()
+            cm.quit()
+            break
+        elif choice == '_close_curr_cont':
+            # Close all problem tabs
+            if cm.tabs and len(cm.tabs) > 1:
+                cm.browser.driver.switch_to.window(cm.tabs[0])
+
+                for tab in cm.tabs[1:]:
+                    cm.browser.driver.switch_to.window(tab)
+                    cm.browser.driver.close()
+
+                cm.tabs = [cm.tabs[0]]
+                cm.browser.driver.switch_to.window(cm.tabs[0])
+                print(f"{Fore.GREEN} Closed contest tabs successfully! \u2714")
+
+                dashboard_text = " Loading Dashboard now ..."
+                for char in dashboard_text:
+                    sys.stdout.write(Fore.YELLOW + char)
+                    sys.stdout.flush()
+                    time.sleep(0.04)
+
+                sys.stdout.write('\n')
+                cm.goto_dashboard()
+
+            quest_list.pop(4)
+            quest_list.pop(3)
+            quest_list.insert(3, Choice(value="_contest_ini", name="Open Contest"))
+            
+            # Reset problems list
+            cm.problems = []
+
+            # Reset contest ID and directory
+            cm.contest_id = None
+            cm.contest_dir = None
+        elif choice == '_track_problelm':
+            cm.show_tracker()
+        elif choice == '_contest_again':
+            # Close all problem tabs except the first one (contest page)
+            if cm.tabs and len(cm.tabs) > 1:
+                # Switch to first tab (contest page)
+                cm.browser.driver.switch_to.window(cm.tabs[0])
+                
+                # Close all problem tabs
+                for tab in cm.tabs[1:]:
+                    cm.browser.driver.switch_to.window(tab)
+                    cm.browser.driver.close()
+                    
+                # Reset tabs list to only include the first tab
+                cm.tabs = [cm.tabs[0]]
+                cm.browser.driver.switch_to.window(cm.tabs[0])
+                print(f"{Fore.GREEN} Closed previous contest tabs successfully! \u2714")
+            
+            # Reset problems list
+            cm.problems = []
+            
+            # Reset contest ID and directory
+            cm.contest_id = None
+            cm.contest_dir = None
+            
+            # Open new contest
+            cm.open_contest()
+        else: click.echo(f"{Fore.RED} Invalid choice!")
+# --------------------------------------------------------
+
+cli.add_command(interactive)
+
+# ------ Main Script -------
+if __name__ == "__main__":
+    interactive()
+# --------------------------

chefmate/config.py

@@ -0,0 +1,64 @@
+# config.py
+import os
+import json
+
+DEFAULT_CONFIG_DIR = os.path.join(os.path.expanduser("~"), ".chefmate")
+DEFAULT_CONFIG_FILE = os.path.join(DEFAULT_CONFIG_DIR, "config.json")
+
+class Config:
+    """Configuration manager for ChefMate"""
+
+    def __init__(self, config_file=DEFAULT_CONFIG_FILE):
+        self.config_file = config_file
+        self.config = self.load_config()
+
+    def load_config(self):
+        """Load configuration from file or create default"""
+        if not os.path.exists(os.path.dirname(self.config_file)):
+            os.makedirs(os.path.dirname(self.config_file))
+
+        if os.path.exists(self.config_file):
+            try:
+                with open(self.config_file, 'r') as f:
+                    return json.load(f)
+            except json.JSONDecodeError:
+                print(f"Error: Config file {self.config_file} is corrupted. Creating new config.")
+                return self.create_default_config()
+        else:
+            return self.create_default_config()
+
+    def create_default_config(self):
+        """Create default configuration"""
+        pc_username = os.getlogin()
+        config = {
+            "username": "",
+            "password": "",
+            "preferred_language": "",
+            "solution_path": "",
+            "chrome_user_data_dir": fr"C:\\Users\\{pc_username}\\AppData\\Local\\Google\\Chrome\\User Data",
+            "chrome_profile": "Default",
+            "preferred_editor": ""
+        }
+        self.save_config(config)
+        return config
+
+    def save_config(self, config=None):
+        """Save configuration to file"""
+        if config is None:
+            config = self.config
+        with open(self.config_file, 'w') as f:
+            json.dump(config, f, indent=4)
+
+    def update_config(self, **kwargs):
+        """Update configuration with provided values"""
+        self.config.update(kwargs)
+        self.save_config()
+
+    def get(self, key, default=None):
+        """Get configuration value"""
+        return self.config.get(key, default)
+
+    def set(self, key, value):
+        """Set configuration value"""
+        self.config[key] = value
+        self.save_config()

chefmate-1.0.0.dist-info/METADATA

@@ -0,0 +1,313 @@
+Metadata-Version: 2.4
+Name: chefmate
+Version: 1.0.0
+Summary: A CodeChef automation CLI tool
+Home-page: https://github.com/Anuj-72/ChefMate
+Author: Anuj Kumar Sah
+Author-email: anujsah282005@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: selenium
+Requires-Dist: webdriver-manager
+Requires-Dist: click
+Requires-Dist: colorama
+Requires-Dist: inquirer
+Requires-Dist: InquirerPy
+Requires-Dist: rich
+Requires-Dist: tabulate
+Requires-Dist: pandas
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# ChefMate
+
+ChefMate is an automation tool designed to simplify and streamline your CodeChef contest participation. It leverages browser automation (using Selenium and ChromeDriver) along with a versatile command-line interface (CLI) to handle tasks such as logging in, contest management, problem scraping, solution submissions, and demo test case validations. ChefMate also helps set up directories and template files so that you can focus on solving problems quickly and efficiently.
+
+---
+
+## Table of Contents
+
+- [Introduction](#introduction)
+- [Features](#features)
+- [Architecture and Code Structure](#architecture-and-code-structure)
+  - [Browser Manager (`browser_manager.py`)](#browser-manager)
+  - [Core Functionality (`chefmate_core.py`)](#core-functionality)
+  - [Command Line Interface (`cli.py`)](#command-line-interface)
+  - [Configuration Management (`config.py`)](#configuration-management)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Setup](#setup)
+  - [Login and Logout](#login-and-logout)
+  - [Contest and Problem Management](#contest-and-problem-management)
+  - [Testing and Submissions](#testing-and-submissions)
+  - [Interactive Mode](#interactive-mode)
+- [Dependencies](#dependencies)
+- [Troubleshooting](#troubleshooting)
+- [Future Improvements](#future-improvements)
+- [License](#license)
+
+---
+
+## Introduction
+
+ChefMate is built to help competitive programmers who participate in CodeChef contests. By automating several routine tasks (such as logging in, opening contest pages, fetching problems, and managing solution submissions), ChefMate removes friction from the contest environment. With its modular design, the tool offers easy configurability and a friendly CLI interface, making the CodeChef contest experience smoother and more productive.
+
+---
+
+## Features
+
+- **Browser Management:**  
+  - Detects and prevents conflicts with existing Chrome sessions.
+  - Initializes a ChromeDriver with custom profiles and directories.
+  - Configurable options to bypass common Chrome logging and automation detections.
+
+- **Automated Contest Interaction:**  
+  - Logs into CodeChef and navigates to the contest dashboard.
+  - Opens contest pages and scrapes problem links and details.
+  - Provides an interactive problem tracker to monitor submission statuses.
+
+- **Solution Management:**  
+  - Creates and manages solution directories for contests.
+  - Generates template solution files in your preferred programming language.
+  - Facilitates opening solution files in your favorite code editor.
+
+- **Submission and Testing:**  
+  - Automates the process of selecting the language from the CodeChef UI.
+  - Loads solutions from files and submits them via the browser.
+  - Runs sample test cases to verify outputs before actual submission.
+  - Displays detailed verdict tables and highlights errors.
+
+- **Command-Line Interface (CLI):**  
+  - Offers a range of commands (setup, login, logout, contest, submit, check, interactive mode).
+  - Provides an intuitive interactive mode with a clear menu-driven experience.
+  - Uses libraries such as Click and InquirerPy for enhanced user interaction.
+
+- **Configuration Management:**  
+  - Manages user settings (username, password, solution paths, preferred language, Chrome profile, editor preferences) through a JSON configuration file stored in the user's home directory.
+  - Ensures persistence and easy updates of user configuration.
+
+---
+
+## Architecture and Code Structure
+
+ChefMate’s code is organized into four main modules:
+
+### Browser Manager
+
+**File:** `browser_manager.py`
+
+- **Purpose:**  
+  Manages the Chrome browser session using Selenium WebDriver.  
+- **Key Functions:**
+  - **Initialization:** Sets up the ChromeDriver with options such as user-data-dir and profile-directory for isolated sessions.
+  - **Conflict Detection:** Checks if a Chrome instance is already running and prompts the user accordingly.
+  - **Session Management:** Provides methods to initialize, operate, and close the browser session.  
+- **Highlights:**  
+  Uses `webdriver_manager` to ensure the correct ChromeDriver is installed and employs custom options to reduce unwanted automation flags.
+
+### Core Functionality
+
+**File:** `chefmate_core.py`
+
+- **Purpose:**  
+  Acts as the primary interface to ChefMate functionality. It integrates browser automation with the CodeChef website.  
+- **Components:**
+  - **Login/Logout:**  
+    Automates the CodeChef login procedure including form filling, waiting for dashboard elements, and handling potential errors.
+  - **Contest Handling:**  
+    Opens a contest page, scrapes all available problem links, and dynamically creates a problem tracker.
+  - **Solution Handling:**  
+    Searches for or prompts for the correct solution file. Generates solution templates based on the preferred programming language.
+  - **Submission and Testing:**  
+    Provides mechanisms to load code into the CodeChef code editor, submit solutions, and analyze output results by parsing verdict tables.
+  - **Interactive Utilities:**  
+    Functions like typewriter text effects, dashboard redirection, and dynamic problem tracking to enhance the user experience.
+
+### Command Line Interface
+
+**File:** `cli.py`
+
+- **Purpose:**  
+  Provides a user-friendly CLI to interact with ChefMate.  
+- **Features:**
+  - **CLI Commands:**  
+    Implements commands using Click. Commands include `setup`, `login`, `logout`, `check`, `submit`, `contest`, and `interactive`.
+  - **Interactive Mode:**  
+    An extended menu-driven interface built using InquirerPy that lets users select among different operational modes such as logging in, solving problems, or reconfiguring settings.
+  - **UI Enhancements:**  
+    Uses the Rich library for improved terminal output, such as styled tables and animated loaders.
+
+### Configuration Management
+
+**File:** `config.py`
+
+- **Purpose:**  
+  Handles persistent configurations for ChefMate by reading from and writing to a JSON file.  
+- **Details:**
+  - **Default Configuration:**  
+    Automatically creates a configuration file in the user's home directory (`~/.chefmate/config.json`) if it does not exist.
+  - **Dynamic Updates:**  
+    Offers methods to get, set, and update various settings including username, password, preferred language, solution file paths, and Chrome user data directories.
+  - **Robustness:**  
+    Includes error handling to recreate a default configuration if the current configuration file is corrupted.
+
+---
+
+## Installation
+
+1. **Clone the Repository:**
+
+   ```bash
+   git clone https://github.com/yourusername/chefmate.git
+   cd chefmate
+   ```
+
+2. **Set Up a Python Virtual Environment (Optional but Recommended):**
+
+   ```bash
+   python -m venv venv
+   source venv/bin/activate   # Linux/Mac
+   venv\Scripts\activate      # Windows
+   ```
+
+3. **Install Dependencies:**
+
+   ChefMate relies on several Python packages. Install them using:
+
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+   > **Note:** Dependencies include libraries like Selenium, webdriver-manager, Click, InquirerPy, Rich, and Colorama. Make sure your environment meets the prerequisites for Selenium and ChromeDriver.
+
+---
+
+## Usage
+
+### Setup
+
+Run the setup command to configure ChefMate with your CodeChef credentials, preferred language, editor, and solution file path:
+
+```bash
+python cli.py setup
+```
+
+### Login and Logout
+
+To login to CodeChef, use:
+
+```bash
+python cli.py login
+```
+
+And to logout:
+
+```bash
+python cli.py logout
+```
+
+### Contest and Problem Management
+
+- **Opening a Contest:**  
+  Launch a contest by providing the contest ID and your division using:
+
+  ```bash
+  python cli.py contest
+  ```
+
+- **Automatic Problem Scraping:**  
+  ChefMate will automatically identify and open all the contest problem tabs and display a problem tracker.
+
+### Testing and Submissions
+
+- **Check Demo Test Cases:**  
+  Validate your solution using sample test cases:
+
+  ```bash
+  python cli.py check --problem 1
+  ```
+
+- **Submitting a Solution:**  
+  To submit your solution for a given problem:
+
+  ```bash
+  python cli.py submit --problem 1
+  ```
+
+- **Solving Problems (Template Generation & File Management):**  
+  ChefMate automatically generates solution template files in a designated contest directory for you to edit. It opens the selected file in your preferred text editor.
+
+### Interactive Mode
+
+ChefMate also offers an interactive mode that provides a dynamic menu for operations. Launch it with:
+
+```bash
+python cli.py interactive
+```
+
+In this mode, you can choose among several actions such as login, logout, opening contests, checking demo cases, submitting solutions, and reconfiguring settings.
+
+---
+
+## Dependencies
+
+- **Selenium:** For browser automation and web interactions.
+- **webdriver-manager:** To handle ChromeDriver installation and updates.
+- **Click & InquirerPy:** For building the CLI and interactive prompts.
+- **Rich & Colorama:** For styled terminal outputs and color support.
+- **Pandas & Tabulate:** For generating and displaying submission verdict tables.
+
+Make sure you have the latest version of Google Chrome installed to ensure compatibility with ChromeDriver.
+
+---
+
+## Troubleshooting
+
+- **Chrome Profile in Use:**  
+  If you receive an error indicating that the Chrome profile is already being used, ensure that all Chrome windows are closed before starting ChefMate.
+
+- **Solution File Issues:**  
+  If ChefMate cannot locate your solution file, double-check the path in the configuration (or re-run the `setup` command).
+
+- **Configuration Errors:**  
+  If the configuration file is corrupted, ChefMate will automatically generate a new default configuration in `~/.chefmate/config.json`.
+
+- **Network/Slow Load Problems:**  
+  For slow networks, ChefMate includes retries during login and test case checks. If problems persist, try restarting your browser or re-running the command.
+
+---
+
+## Future Improvements
+
+- **Enhanced Error Reporting:**  
+  Additional debugging information for failures during submissions and test case validations.
+- **Multi-Language Support:**  
+  Extending support for more languages and custom code editor integration.
+- **GUI Implementation:**  
+  A graphical user interface for those who prefer not to use the CLI.
+- **Extended Contest Support:**  
+  Integration with more competitive programming sites.
+
+---
+
+## License
+
+ChefMate is open source software released under the [MIT License](LICENSE).
+
+---
+
+ChefMate is designed with flexibility and practicality in mind to reduce the repetitive tasks of contest participation, leaving you free to concentrate on solving problems and improving your competitive programming skills.
+
+Happy Coding!

chefmate-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+chefmate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chefmate/browser_manager.py,sha256=V1khfGVj8aeOmuQmVZLHs5H56vZRvtI97-nNe6pTK6E,2866
+chefmate/chefmate_core.py,sha256=F66-7gJJtn0_a6nM3HWLe58-3ExcAA82HK0ujmzrmEU,69631
+chefmate/cli.py,sha256=5GtohPcnSY8ygqLqZyMwZQioWfvMlF9KHTvYN15CB-4,9323
+chefmate/config.py,sha256=itkFruFKMX7eday8UnAYOfnVMthivn20tiTlG87czyA,2220
+chefmate-1.0.0.dist-info/licenses/LICENSE,sha256=gIUzdNdf-vbONssDRz-fj0uTywroTk9_ZBedvpj57XU,1094
+chefmate-1.0.0.dist-info/METADATA,sha256=0rjISJSFc-cUYZqDtbWJdvmf1I8_0Rca49Vbe7to_B4,11858
+chefmate-1.0.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+chefmate-1.0.0.dist-info/entry_points.txt,sha256=JajQonz6c_uzwcHALUk6VA_zxMhDPsdHC-Z7lJedyyA,46
+chefmate-1.0.0.dist-info/top_level.txt,sha256=jOlvGtNNEYlsbwLBD2lpAmZBSo1wq2dydfAM1lP_Ago,9
+chefmate-1.0.0.dist-info/RECORD,,

chefmate-1.0.0.dist-info/WHEEL

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

chefmate-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+chefmate = chefmate.cli:cli

chefmate-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2025] [Anuj Kumar Sah]
+
+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.