Add company-specific problem practice functionality

Introduced "Company Mode" to handle questions based on specific companies and their recent trends. This includes company-based filters, durations, topics, and difficulties with caching support and validation to enhance user experience and efficiency.

Author: nicholasadamou

README.md

@@ -15,6 +15,7 @@ Squidleet is a command-line LeetCode practice game that allows you to solve Leet
 - **Daily Challenge Integration**: Fetch and solve the LeetCode Daily Coding Challenge directly from the terminal.
 - **Study Plan Mode**: Fetch random problems based on a specific study plan.
 - **Random Problem Practice**: Get a randomly selected LeetCode problem to practice.
+- **Company Mode**: Fetch random problems asked by a specific company over a given duration (e.g., last 30 days).
 - **Specific Problem Mode**: Solve a specific problem by providing its problem slug.
 - **Problem Fetching**: Added enhanced fetching capabilities, including filtering based on difficulty (e.g., `easy`, `medium`, `hard`) and more.
 - **Submit Solutions**: Users can now directly submit their solutions to LeetCode from the terminal via a `submit_solution` function.
@@ -151,6 +152,36 @@ Selected 🎯 Study Plan Mode: top-interview-150
 ⏳ You have 45 min minutes to solve the problem. Good luck!
 ```
 
+### Company Mode
+
+Company Mode allows you to fetch random problems asked by a specific company.
+
+⚠️ **Note**: This mode requires the `--leetcode-session` argument to be set with a valid LeetCode session cookie. This is because the company-specific problem data is not available publicly and requires a valid [LeetCode Premium](https://leetcode.com/subscribe) subscription.
+
+```bash
+python3 main.py --mode company --company-name microsoft --duration thirty-days
+```
+
+Optional arguments:
+- `--open-in-browser`: Opens the problem in a browser window.
+- `--editor`: Specify the preferred code editor (e.g., `vim`, `nano`). Default is the system-configured default editor.
+- `--difficulty`: Choose between `easy`, `medium`, or `hard` or select multiple using comma-separated list (e.g., `easy,medium`).
+- `--tags`: Filter problems based on tags. Example usage: `--tags Array,Hash Table`.
+- `--duration`: Fetch the problems asked by the company over a given span of time. Valid values: `thirty-days`, `three-months`, `six-months`, `more-than-six-months`, or `all`. Default is `all`.
+
+```text
+Welcome to 🦑 SquidLeet!
+🔐 Using authenticated session
+Selected 👔 Company Mode: Top Questions asked at Microsoft in the last 30 days
+🎯 Problem Selected: Maximum Length of a Concatenated String with Unique Characters
+✨ Difficulty: Medium
+🔗 URL: https://leetcode.com/problems/maximum-length-of-a-concatenated-string-with-unique-characters
+🏷️ Tags: Array, String, Backtracking, Bit Manipulation
+📈 Acceptance Rate: 54.2%
+...
+⏳ You have 45 min minutes to solve the problem. Good luck!
+```
+
 ## Configurations
 Squidleet uses a `LEETCODE_SESSION` cookie for authentication. Setting the `LEETCODE_SESSION` environment variable is necessary for all operations, including fetching and submitting problems.
 

api/CachedLeetCodeAPI.py

@@ -1,14 +1,23 @@
 import json
 import hashlib
 import tempfile
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, List
 from pathlib import Path
 import time
 
 from api.LeetCodeAPI import LeetCodeAPI
 from utils.logger import log, LogLevel
 
 
+def _get_cache_key(unique_id: str) -> str:
+    """
+    Generate a cache key based on a unique identifier (e.g., query or API parameters).
+    :param unique_id: Unique identifier for the API request (e.g., slug, query, variable JSON).
+    :return: Cache filename based on the MD5 hash of the unique ID.
+    """
+    return hashlib.md5(unique_id.encode("utf-8")).hexdigest()
+
+
 class CachedLeetCodeAPI:
     def __init__(self, cache_dir: Optional[str] = None, cache_expiry: int = 3600):
         """
@@ -29,14 +38,6 @@ def __init__(self, cache_dir: Optional[str] = None, cache_expiry: int = 3600):
             LeetCodeAPI()
         )  # Delegate actual API calls to existing LeetCodeAPI class
 
-    def _get_cache_key(self, unique_id: str) -> str:
-        """
-        Generate a cache key based on a unique identifier (e.g., query or API parameters).
-        :param unique_id: Unique identifier for the API request (e.g., slug, query, variable JSON).
-        :return: Cache filename based on the MD5 hash of the unique ID.
-        """
-        return hashlib.md5(unique_id.encode("utf-8")).hexdigest()
-
     def _read_from_cache(self, cache_key: str) -> Any:
         """
         Read data from cache if it exists and is valid.
@@ -73,7 +74,7 @@ def _fetch_with_cache(
         :param kwargs: Keyword arguments to pass to the fetch function.
         :return: Fetched or cached data.
         """
-        cache_key = self._get_cache_key(unique_id)
+        cache_key = _get_cache_key(unique_id)
 
         # Check cache first
         cached_data = self._read_from_cache(cache_key)
@@ -104,7 +105,7 @@ def fetch_daily_challenge(self, *args, **kwargs):
         Cached version of fetch_daily_challenge
         """
         return self._fetch_with_cache(
-            self.api.fetch_daily_challenge, "fetch_daily_challenge"
+            self.api.fetch_daily_challenge, "fetch_daily_challenge", *args, **kwargs
         )
 
     def fetch_problem(self, problem_slug: str, *args, **kwargs):
@@ -124,3 +125,107 @@ def get_study_plan(self, slug: str, *args, **kwargs):
         return self._fetch_with_cache(
             self.api.get_study_plan, unique_id, slug, *args, **kwargs
         )
+
+    def fetch_company_questions(self, company_slug: str, *args, **kwargs):
+        """
+        Cached version of fetch_company_questions
+        """
+        unique_id = f"fetch_company_questions-{company_slug}"
+        return self._fetch_with_cache(
+            self.api.fetch_company_questions, unique_id, company_slug, *args, **kwargs
+        )
+
+    def fetch_company_questions_for_duration(
+        self,
+        company_name: str,
+        duration: str,
+        difficulties: Optional[List[str]] = None,
+        tags: Optional[list] = None,
+        *args,
+        **kwargs,
+    ):
+        """
+        Wrapper around `fetch_company_questions` that accepts a company name,
+        duration, and an optional difficulty filter to fetch questions for a specific time range.
+
+        This method is cached to avoid redundant API calls.
+
+        :param company_name: Name of the company (e.g., 'amazon', 'google').
+        :param duration: Duration to filter questions (e.g., 'thirty-days', 'three-months').
+                         Valid durations:
+                         - "thirty-days"
+                         - "three-months"
+                         - "six-months"
+                         - "more-than-six-months"
+                         - "all"
+        :param difficulties: (Optional) Difficulty filter to narrow down the results.
+                           Valid options: "EASY", "MEDIUM", "HARD".
+        :param tags: (Optional) List of topic tags to filter the questions.
+        :return: A dictionary containing the questions and metadata.
+        """
+
+        # Validate duration input
+        valid_durations = [
+            "thirty-days",
+            "three-months",
+            "six-months",
+            "more-than-six-months",
+            "all",
+        ]
+        if duration not in valid_durations:
+            raise ValueError(
+                f"Invalid duration: {duration}. Must be one of {valid_durations}."
+            )
+
+        # Validate difficulty input
+        valid_difficulties = ["EASY", "MEDIUM", "HARD"]
+        difficulty_filter = None
+        if difficulties:
+            if difficulties not in valid_difficulties:
+                raise ValueError(
+                    f"Invalid difficulty: {difficulties}. Must be one of {valid_difficulties}."
+                )
+
+            # Create a difficulty filter with the operator "IS"
+            difficulty_filter = {"difficulties": difficulties, "operator": "IS"}
+
+        # Validate tags input
+        topic_filter = None
+        if tags:
+            topic_tags = self.api.get_topic_tags()
+            valid_tags = [tag.lower() for tag in topic_tags]
+            standardized_tags = [tag.lower() for tag in tags]
+            if any(tag not in valid_tags for tag in standardized_tags):
+                raise ValueError(
+                    f"Invalid tags. Supported tags: {', '.join(valid_tags)}"
+                )
+
+            # Create a topic filter with the operator "IS"
+            topic_filter = {
+                "tags": standardized_tags,
+                "operator": "IS",
+            }
+
+        # Construct the favorite_slug based on company name and duration
+        favorite_slug = f"{company_name.lower()}-{duration}"
+
+        # Append difficulties to the unique id if provided
+        unique_id = (
+            f"{favorite_slug}-{'-'.join(difficulties)}"
+            if difficulties
+            else favorite_slug
+        )
+
+        results = self._fetch_with_cache(
+            self.api.fetch_company_questions,
+            unique_id,
+            favorite_slug,
+            difficulty_filter,
+            topic_filter,
+            *args,
+            **kwargs,
+        )
+
+        # Navigate to the questions in the actual response structure
+        favorite_question_list = results.get("data", {}).get("favoriteQuestionList", {})
+        return favorite_question_list.get("questions", [])