LeetScrape

https://nikhil-ravi.github.io/LeetScrape/
Admin
LeetScrape is a Python package that scrapes LeetCode problem statements, test cases, and code stubs...
Tokens:12,112
Snippets:73
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Run LeetScrape TS Project with npm

Source: https://nikhil-ravi.github.io/LeetScrape/leetscrape_ts

Navigate to the project directory and run this command to start the development server using npm. Ensure Node.js and npm are installed.

```bash
cd ./ts
npm run dev
```

--------------------------------

### Run LeetScrape TS Project with Bun

Source: https://nikhil-ravi.github.io/LeetScrape/leetscrape_ts

Navigate to the project directory and run this command to start the development server using Bun. Ensure Bun is installed.

```bash
cd ./ts
bun dev
```

--------------------------------

### Run LeetScrape TS Project with pnpm

Source: https://nikhil-ravi.github.io/LeetScrape/leetscrape_ts

Navigate to the project directory and run this command to start the development server using pnpm. Ensure pnpm is installed.

```bash
cd ./ts
pnpm dev
```

--------------------------------

### Run LeetScrape TS Project with Yarn

Source: https://nikhil-ravi.github.io/LeetScrape/leetscrape_ts

Navigate to the project directory and run this command to start the development server using Yarn. Ensure Yarn is installed.

```bash
cd ./ts
yarn dev
```

--------------------------------

### Install Leetscrape

Source: https://nikhil-ravi.github.io/LeetScrape/installation

Install the package using pip, conda, or poetry.

```shell
pip install leetscrape
```

```shell
conda install leetscrape
```

```shell
poetry add leetscrape
```

--------------------------------

### Generate LeetScrape TS Project

Source: https://nikhil-ravi.github.io/LeetScrape/leetscrape_ts

Use this command to bootstrap a new LeetScrape TS project in a specified directory. Ensure you follow the README instructions for further setup.

```bash
leetscrape ts --out ./ts
```

--------------------------------

### Scrape and display LeetCode questions

Source: https://nikhil-ravi.github.io/LeetScrape/questions_list

Initialize the scraper, execute the scrape process, and preview the resulting data.

```python
from leetscrape import GetQuestionsList

ls = GetQuestionsList()
ls.scrape() # Scrape the list of questions
ls.questions.head() # Get the list of questions
```

--------------------------------

### CLI Command: list

Source: https://nikhil-ravi.github.io/LeetScrape/installation

Lists all available LeetCode questions.

```APIDOC
## CLI Command: list

### Description
List all questions without generating code stub.

### Parameters
#### Options
- **--out, -o** (string) - Optional - Specify the output file name to store the list of questions.
```

--------------------------------

### Solution Command Options

Source: https://nikhil-ravi.github.io/LeetScrape/installation

View positional arguments and options for generating MDX files from solutions.

```text
positional arguments:
input              Enter the path to the solution directory with solution files or to a single
                    solution file

options:
-h, --help         show this help message and exit
--out OUT, -o OUT  Enter the path to the output directory to save solutions mdx files
```

--------------------------------

### CLI Command: solution

Source: https://nikhil-ravi.github.io/LeetScrape/installation

Converts solution files into MDX format.

```APIDOC
## CLI Command: solution

### Description
Generate mdx files from solutions.

### Parameters
#### Positional Arguments
- **input** (string) - Required - Enter the path to the solution directory with solution files or to a single solution file

#### Options
- **--out, -o** (string) - Optional - Enter the path to the output directory to save solutions mdx files
```

--------------------------------

### TS Command Options

Source: https://nikhil-ravi.github.io/LeetScrape/installation

View help and output configuration for creating the Next.js project.

```text
options:
-h, --help         show a help message and exit
--out OUT, -o OUT  Enter the path to the output directory to save the project
```

--------------------------------

### CLI Command: ts

Source: https://nikhil-ravi.github.io/LeetScrape/installation

Scaffolds a Next.js project for hosting solutions.

```APIDOC
## CLI Command: ts

### Description
Create the leetscrape-ts Next.js project to host the solutions.

### Parameters
#### Options
- **--out, -o** (string) - Optional - Enter the path to the output directory to save the project
```

--------------------------------

### CLI Command: question

Source: https://nikhil-ravi.github.io/LeetScrape/installation

Generates a code stub for specified LeetCode questions.

```APIDOC
## CLI Command: question

### Description
Generate a code stub for the given question(s).

### Parameters
#### Positional Arguments
- **qid** (list) - Required - Enter Leetcode question ID(s)

#### Options
- **--out, -o** (string) - Optional - Enter the path to the output directory
```

--------------------------------

### List Questions Command Options

Source: https://nikhil-ravi.github.io/LeetScrape/installation

View help and output configuration for the list command.

```text
options:
-h, --help         show a help message and exit
--out OUT, -o OUT  Specify the output file name to store the list of questions.
```

--------------------------------

### Question Command Options

Source: https://nikhil-ravi.github.io/LeetScrape/installation

View positional arguments and options for generating code stubs.

```text
positional arguments:
qid                Enter Leetcode question ID(s)

options:
-h, --help         show this help message and exit
--out OUT, -o OUT  Enter the path to the output directory
```

--------------------------------

### Extract and Convert Solutions to MDX

Source: https://nikhil-ravi.github.io/LeetScrape/extract_solution

Use this snippet to initialize the extractor with a source file and generate an MDX output file.

```python
ExtractSolutions(filename="<path-to-solution-file>").to_mdx(output_filename="<path-to-output-file>")
```

--------------------------------

### Retrieve a LeetCode question

Source: https://nikhil-ravi.github.io/LeetScrape/question

Initialize the GetQuestion class with a title slug and call the scrape method to fetch question details.

```python
question = GetQuestion(titleSlug="two-sum").scrape()
```

--------------------------------

### Import GetQuestion Class

Source: https://nikhil-ravi.github.io/LeetScrape/question

Import the GetQuestion class from the leetscrape library to query individual question information.

```python
from leetscrape import GetQuestion
```

--------------------------------

### GetQuestionsList - Scrape and Export

Source: https://nikhil-ravi.github.io/LeetScrape/questions_list

This snippet demonstrates how to initialize the GetQuestionsList class, scrape question data, and export it to CSV files.

```APIDOC
## GetQuestionsList - Scrape and Export

### Description
This section details the usage of the `GetQuestionsList` class to scrape LeetCode questions and related data, and then export this data into CSV files.

### Class
`GetQuestionsList`

### Initialization
```python
from leetscrape import GetQuestionsList

# Initialize the scraper with an optional limit
ls = GetQuestionsList(limit=5000) # Default limit is 10000
```

### Methods
#### `scrape()`
Scrapes LeetCode data including company tags, questions, question topics, and categories.

```python
ls.scrape()
```

#### `to_csv(directory)`
Exports the scraped data into CSV files in the specified directory.

**Parameters:**
- **directory** (str) - Required - The directory path to export the scraped data into.

```python
ls.to_csv(directory="./data/")
```

### Data Exported
This method generates the following CSV files in the specified directory:
- `questions.csv`: List of questions with title, difficulty, acceptance rate, paid status, topic tags, and category.
- `companies.csv`: List of companies with name, slug, and question count.
- `topicsTags.csv`: List of topic tags with name and slug.
- `categories.csv`: List of categories with name and slug.
- `questionCategory.csv`: An edgelist of questions and their categories.
- `questionTopics.csv`: An edgelist of questions and their topic tags.

### Class Parameters
#### `limit`
- **limit** (int) - Optional - The maximum number of questions to query for from Leetcode’s graphql API. Defaults to 10,000.

### Example Usage
```python
from leetscrape import GetQuestionsList

# Initialize the scraper
ls = GetQuestionsList()

# Scrape the list of questions
ls.scrape()

# Display the first few rows of the questions data
print(ls.questions.head())

# Export all scraped data to CSV files in the 'output_csv' directory
ls.to_csv(directory="./output_csv/")
```
```

--------------------------------

### Generate LeetScrape Solution MDX Files

Source: https://nikhil-ravi.github.io/LeetScrape/leetscrape_ts

This command generates MDX files for your solutions from a specified directory. This is a necessary step after project generation and before running the project.

```bash
leetscrape solution --out ./ts/src/content/solutions ./solutions
```

--------------------------------

### POST /graphql (GetQuestion.scrape)

Source: https://nikhil-ravi.github.io/LeetScrape/question

Retrieves detailed information about a specific LeetCode question by its title slug.

```APIDOC
## POST /graphql

### Description
Queries the LeetCode GraphQL API to retrieve metadata, hints, code snippets, and the problem body for a given question.

### Method
POST

### Endpoint
/graphql

### Parameters
#### Request Body
- **query** (string) - Required - The GraphQL query string for question details.
- **variables** (object) - Required - Contains the 'titleSlug' parameter.
  - **titleSlug** (string) - Required - The unique slug identifier for the LeetCode question.

### Response
#### Success Response (200)
- **QID** (string) - Question ID
- **title** (string) - Question title
- **titleSlug** (string) - Question title slug
- **difficulty** (string) - Question difficulty level
- **Hints** (array) - List of hints for the problem
- **Companies** (array) - List of companies associated with the question
- **topics** (array) - List of topic tags
- **isPaidOnly** (boolean) - Whether the question is premium-only
- **Body** (string) - The problem statement/content
- **Code** (object) - Available code stubs
- **SimilarQuestions** (array) - List of similar question IDs
```

--------------------------------

### Generate Code Stub and Test Files

Source: https://nikhil-ravi.github.io/LeetScrape/generate_code_stubs

Wraps the creation of code stub and test files, formatting them with Black. This function handles file writing to the specified directory.

```python
def generate(self, testing=False, directory: str = ".") -> None:
    """Wrapper that creates the code stub and test files after formatting them through black.

    Args:
        testing (bool, optional): Whether we are in a testing environment. In testing environment, the files are not written to the disk. Defaults to False.
        directory (str, optional): The directory where the files are to be written. Defaults to ".".
    """
    if directory.endswith("/"):
        directory = directory[:-1]
    code_to_write = self._create_code_file()
    if not self.data.isPaidOnly:
        test_to_write = self._create_test_file(code_to_write)
    if not testing:
        with open(f"{directory}/{self.filename}", "w", encoding="utf-8") as f:
            f.write(format_str(code_to_write, mode=FileMode()))
            print(f"Code stub save to {self.filename}")

        if not self.data.isPaidOnly:
            with open(
                f"{directory}/test_{self.filename}", "w", encoding="utf-8"
            ) as f:
                f.write(
                    format_str(test_to_write, mode=FileMode()) # ignore: unbounded
                )
                print(f"Test file written to test_{self.filename}.py")
```

--------------------------------

### Generate a LeetCode code stub

Source: https://nikhil-ravi.github.io/LeetScrape/generate_code_stubs

Instantiate the generator with a question identifier and call the generate method to create the files in a specified directory.

```python
fcs = GenerateCodeStub(titleSlug="two-sum")
fcs.generate(directory="<dir>")
```

--------------------------------

### Generate MDX File using to_mdx

Source: https://nikhil-ravi.github.io/LeetScrape/extract_solution

Use the to_mdx method of the ExtractSolutions class to directly generate an MDX file from your LeetCode solutions.

```python
from leetscrape import ExtractSolutions


```

--------------------------------

### scrape()

Source: https://nikhil-ravi.github.io/LeetScrape/questions_list

Executes the scraping process to collect company tags, questions, topics, and categories from LeetCode.

```APIDOC
## scrape()

### Description
Scrapes LeetCode data including company tags, questions, question topics, and categories.

### Method
Internal Method

### Parameters
None
```

--------------------------------

### Retrieve Categories and Topic Tags

Source: https://nikhil-ravi.github.io/LeetScrape/questions_list

Initializes the categories and topicTags attributes from predefined constants.

```python
    def _get_categories_and_topicTags_lists(self):
        """Get the categories and topic tags of LeetCode problems and store them in the
        'categories' and 'topicTags' attribute respectively."""
        print("Getting Categories ... ", end="")
        # List of problem categories
        self.categories = pd.DataFrame.from_records(CATEGORIES)
        print("Done")
        # List of problem topic tags
        print("Scraping Topic Tags ... ", end="")
        self.topicTags = pd.DataFrame.from_records(TOPIC_TAGS)
        print("Done")
```

--------------------------------

### Write code and test files to disk

Source: https://nikhil-ravi.github.io/LeetScrape/generate_code_stubs

Handles file system operations to save generated code stubs and test files, applying formatting via black-compatible tools.

```python
directory = directory[:-1]
        code_to_write = self._create_code_file()
        if not self.data.isPaidOnly:
            test_to_write = self._create_test_file(code_to_write)
        if not testing:
            with open(f"{directory}/{self.filename}", "w", encoding="utf-8") as f:
                f.write(format_str(code_to_write, mode=FileMode()))
                print(f"Code stub save to {self.filename}")

            if not self.data.isPaidOnly:
                with open(
                    f"{directory}/test_{self.filename}", "w", encoding="utf-8"
                ) as f:
                    f.write(
                        format_str(test_to_write, mode=FileMode())
                    )  # ignore: unbounded
                    print(f"Test file written to test_{self.filename}.py")
```

--------------------------------

### POST /generate

Source: https://nikhil-ravi.github.io/LeetScrape/generate_code_stubs

Generates code stubs and test files for a specific problem, optionally writing them to the local filesystem.

```APIDOC
## POST /generate

### Description
Wrapper that creates the code stub and test files after formatting them through black.

### Method
POST

### Endpoint
/generate

### Parameters
#### Query Parameters
- **testing** (bool) - Optional - Whether we are in a testing environment. In testing environment, the files are not written to the disk. Defaults to False.
- **directory** (str) - Optional - The directory where the files are to be written. Defaults to ".".
```

--------------------------------

### Extract Solutions and Problem Statement

Source: https://nikhil-ravi.github.io/LeetScrape/extract_solution

Instantiate ExtractSolutions with the path to your solution file to extract solution objects. Each object contains the solution ID, code, docstrings, and the problem statement.

```python
from leetscrape import ExtractSolutions

# Get the question body
solutions = ExtractSolutions(filename="<path-to-solution-file>").extract()
```

--------------------------------

### Generate Code Stub

Source: https://nikhil-ravi.github.io/LeetScrape/generate_code_stubs

Import and use the GenerateCodeStub class to create code stubs for programming questions. This is useful for setting up a new solution file.

```python
from leetscrape import GenerateCodeStub
```

--------------------------------

### GetQuestion class implementation

Source: https://nikhil-ravi.github.io/LeetScrape/question

The core class responsible for querying the LeetCode GraphQL API and parsing the response into a Question object.

```python
class GetQuestion:
    """
    A class to acquire the statement, constraints, hints, basic test cases, related questions, and code stubs of the given question.

    Args:
        titleSlug (str): The title slug of the question.
    """

    def __init__(self, titleSlug: str):
        self.titleSlug = titleSlug
        self.questions_info = self.fetch_all_questions_id_and_stub()

    @staticmethod
    def fetch_all_questions_id_and_stub():
        req = requests.get("https://leetcode.com/api/problems/all/").json()
        question_data = pd.json_normalize(req["stat_status_pairs"]).rename(
            columns={
                "stat.frontend_question_id": "QID",
                "stat.question__title_slug": "titleSlug",
            }
        )[["QID", "titleSlug"]]

        return question_data.sort_values("QID").set_index("titleSlug")

    def scrape(self) -> Question:
        """This method calls the Leetcode graphql api to query for the hints, companyTags (currently returning null as this is a premium feature), code snippets, and content of the question.

        Raises:
            ValueError: When the connection to Leetcode's graphql api is not established.

        Returns:
            QuestionInfo: Contains the QID, titleSlug, Hints, Companies, Similar Questions, Code stubs, and the body of the question.
        """
        data = {
            "query": """query questionHints($titleSlug: String!) {
                question(titleSlug: $titleSlug) {
                    questionFrontendId
                    title
                    hints
                    difficulty
                    companyTags {
                        name
                        slug
                        imgUrl
                    }
                    topicTags {
                        name
                    }
                    similarQuestions
                    codeSnippets {
                        lang
                        langSlug
                        code
                    }
                    content
                    isPaidOnly
                }
            }
        """,
            "variables": {"titleSlug": self.titleSlug},
        }
        response = requests.post(BASE_URL, json=data)
        if response.status_code == 404:
            raise ValueError("Leetcode's graphql API can't be found.")
        while response.status_code == 429 | 400:
            time.sleep(10)
            response = requests.post(BASE_URL, json=data)
            if response.status_code == 404:
                raise ValueError("Leetcode's graphql API can't be found.")
        response = response.json()
        return Question(
            QID=response["data"]["question"]["questionFrontendId"],
            title=response["data"]["question"]["title"],
            titleSlug=self.titleSlug,
            difficulty=response["data"]["question"]["difficulty"],
            Hints=response["data"]["question"]["hints"],
            Companies=response["data"]["question"]["companyTags"],
            topics=[
                topic["name"] for topic in response["data"]["question"]["topicTags"]
            ],
            isPaidOnly=response["data"]["question"]["isPaidOnly"],
            Body=self._get_question_body(response),
            Code=self._get_code_snippet(response),
            SimilarQuestions=self._get_similar_questions(response),
        )

    def _get_question_body(self, response) -> str:  # type: ignore
        if not response["data"]["question"]["isPaidOnly"]:
```

--------------------------------

### Scrape LeetCode Data

Source: https://nikhil-ravi.github.io/LeetScrape/questions_list

Initiates the scraping process for various LeetCode data points like company tags, questions, topics, and categories. Ensure all helper methods are correctly implemented.

```python
def scrape(self):
    """Scrapes LeetCode data including company tags, questions, question topics,
    and categories.
    """
    self._scrape_companies()
    self._scrape_questions_list()
    self._extract_question_topics()
    self._get_categories_and_topicTags_lists()
    self._scrape_question_category()
    self._add_category_to_questions_list()
```

--------------------------------

### GetQuestion Class Usage

Source: https://nikhil-ravi.github.io/LeetScrape/question

Documentation for the GetQuestion class used to retrieve detailed information for a specific LeetCode question.

```APIDOC
## GetQuestion

### Description
Query individual question’s information such as the body, test cases, constraints, hints, code stubs, and company tags using the GetQuestion class.

### Usage
```python
from leetscrape import GetQuestion
```
```

--------------------------------

### Scrape LeetCode Questions List

Source: https://nikhil-ravi.github.io/LeetScrape/questions_list

Fetches a list of problems from the LeetCode GraphQL API and processes the response into a structured pandas DataFrame.

```python
    def _scrape_questions_list(self):
        """
        Scrapes the list of questions from leetcode.com and store them in the 'questions' dataframe. The columns include the question QID, acceptance rate, difficulty, title, titleSlug, and topic tags. It also has a column indicating whether the question is available only to Leetcode's paying customers.
        """
        print("Scraping questions list ... ", end="")
        data = {
            "query": """query problemsetQuestionList($categorySlug: String, $limit: Int, $skip: Int, $filters: QuestionListFilterInput) {
                    problemsetQuestionList: questionList(
                        categorySlug: $categorySlug
                        limit: $limit
                        skip: $skip
                        filters: $filters
                    ) {
                        total: totalNum
                        questions: data {
                            acceptanceRate: acRate
                            difficulty
                            QID: questionFrontendId
                            paidOnly: isPaidOnly
                            title
                            titleSlug
                            topicTags {
                                slug
                            }
                        }
                    }
                }
            """,
            "variables": {
                "categorySlug": "",
                "skip": 0,
                "limit": self.limit,
                "filters": {},
            },
        }

        r = requests.post("https://leetcode.com/graphql", json=data).json()
        self.questions = pd.json_normalize(
            r["data"]["problemsetQuestionList"]["questions"]
        )[
            [
                "QID",
                "title",
                "titleSlug",
                "difficulty",
                "acceptanceRate",
                "paidOnly",
                "topicTags",
            ]
        ]
        self.questions["topicTags"] = self.questions["topicTags"].apply(
            lambda w: [tag["slug"] for tag in w]
        )
        print("Done")
```

--------------------------------

### Create Pytest Test File

Source: https://nikhil-ravi.github.io/LeetScrape/generate_code_stubs

Generates a pytest test file for a given LeetCode problem's code stub. It extracts parameters and method names to create parameterized test cases.

```python
def _create_test_file(self, code_text: str) -> str:
        """Generates the test file for the given question.

        Args:
            code_text (str): The text that contains the code stub. This is used to get the list of inputs arguments and the name of the method.

        Returns:
            str: The text containing the pytest test case.
        """
        problem_statement = self._get_problem_statement()
        problem_statement_code_blocks = self._extract_codeblocks_in_problem_statement(
            problem_statement
        )
        input_string, output_string = self._get_parameters(
            problem_statement_code_blocks
        )
        pytestParameterDecorator = (
            f"@pytest.mark.parametrize(\"{output_string}\", [{input_string}])"
        )
        className = "Solution"

        # //TODO: This should be used to find the classname instead of hard-coding it to "Solution"

        # # Use the `parse` function to create an AST from the file's contents
        # root = ast.parse(code_text)
        # # Iterate through the top-level nodes in the AST
        # for node in ast.walk(root):
        #     # Check if the node is a ClassDef node
        #     if isinstance(node, ast.ClassDef):
        #         # Check if the class is not commented
        #         if not node.name.startswith("#"):
        #             # Print the class name
        #             print(node.name)  # type: ignore

        methodsName = re.findall("\n    def (.*):", code_text)
        for i, methodName in enumerate(methodsName):
            a, b = methodName.split(") -> ")
            methodsName[i] = f"{a}, output: {b})"
        methods = [
            f"""
    def test_{methodName}:
        sc = {className}()
        assert sc.{methodName.split("(")[0]}({output_string[:-7]}) == output
        """
            for methodName in methodsName
        ]
        test_to_write = f"""import pytest
from {self.filename.split(".py")[0]} import Solution

{pytestParameterDecorator}
class Test{className}:""" + "".join(
            methods
        )

        return test_to_write
```

--------------------------------

### Scrape Leetcode Question Data

Source: https://nikhil-ravi.github.io/LeetScrape/question

Calls the Leetcode graphql API to fetch question details including hints, code snippets, and content. Handles API rate limiting and errors.

```python
def scrape(self) -> Question:
    """This method calls the Leetcode graphql api to query for the hints, companyTags (currently returning null as this is a premium feature), code snippets, and content of the question.

    Raises:
        ValueError: When the connection to Leetcode's graphql api is not established.

    Returns:
        QuestionInfo: Contains the QID, titleSlug, Hints, Companies, Similar Questions, Code stubs, and the body of the question.
    """
    data = {
        "query": """query questionHints($titleSlug: String!) {
            question(titleSlug: $titleSlug) {
                questionFrontendId
                title
                hints
                difficulty
                companyTags {
                    name
                    slug
                    imgUrl
                }
                topicTags {
                    name
                }
                similarQuestions
                codeSnippets {
                    lang
                    langSlug
                    code
                }
                content
                isPaidOnly
            }
        }
    """,
        "variables": {"titleSlug": self.titleSlug},
    }
    response = requests.post(BASE_URL, json=data)
    if response.status_code == 404:
        raise ValueError("Leetcode's graphql API can't be found.")
    while response.status_code == 429 | 400:
        time.sleep(10)
        response = requests.post(BASE_URL, json=data)
        if response.status_code == 404:
            raise ValueError("Leetcode's graphql API can't be found.")
    response = response.json()
    return Question(
        QID=response["data"]["question"]["questionFrontendId"],
        title=response["data"]["question"]["title"],
        titleSlug=self.titleSlug,
        difficulty=response["data"]["question"]["difficulty"],
        Hints=response["data"]["question"]["hints"],
        Companies=response["data"]["question"]["companyTags"],
        topics=[
            topic["name"] for topic in response["data"]["question"]["topicTags"]
        ],
        isPaidOnly=response["data"]["question"]["isPaidOnly"],
        Body=self._get_question_body(response),
        Code=self._get_code_snippet(response),
        SimilarQuestions=self._get_similar_questions(response),
    )
```

--------------------------------

### Extract Solutions from Python File

Source: https://nikhil-ravi.github.io/LeetScrape/extract_solution

This endpoint extracts programming solutions from a given Python file. It requires the file path and optionally accepts a class name to target specific solutions within the file. The extracted solutions include their ID, code, documentation, and the problem statement.

```APIDOC
## extract(top_class_name='Solution')

### Description
Extract solutions from a given python file.

### Method
GET

### Endpoint
/websites/nikhil-ravi_github_io_leetscrape/extract

### Parameters
#### Query Parameters
- **filename** (str) - Required - The path of the file to extract solutions from. This python script should have the solution method(s) in the class named in the top_class-name.
- **top_class_name** (str) - Optional - The name of the class from which to extract the solutions from. Defaults to 'Solution'.

### Raises
- **ValueError**: When the filename does not follow the required convention of `q_{{LEETCODE_QID}}_ {{LEETCODE_TITLE}}.py`.
- **ValueError**: When the provided python file does not have a class named Solution.

### Returns
- **list[Solution]**: A list of solutions, each containing an id, code [and docs].
```

--------------------------------

### Extract Solutions from Python File

Source: https://nikhil-ravi.github.io/LeetScrape/extract_solution

Extracts method definitions from a specified class within a Python file. Requires the file to follow specific naming conventions and contain the target class.

```python
def extract(self, top_class_name: str = "Solution") -> list[Solution]:
    """
    Extract solutions from a given python file.

    Args:
        filename (str): The path of the file to extract solutions from. This python script should have the solution method(s) in the class named in the top_class-name.
        top_class_name (str, optional): The name of the class from which to extract the solutions from. Defaults to `Solution'.

    Raises:
        ValueError: When the filename does not follow the required convention of `q_{{LEETCODE_QID}}_ {{LEETCODE_TITLE}}.py`.
        ValueError: When the provided python file does not have a class named Solution.

    Returns:
        list[Solution]: A list of solutions, each containing an id, code [and docs].
    """

    class_definition = [
        node
        for node in self.module.body
        if isinstance(node, ast.ClassDef) and node.name == top_class_name
    ]
    if not class_definition:
        raise ValueError(
            "The provided python file should have a class named Solution."
        )
    method_definitions = [
        node
        for node in class_definition[0].body
        if isinstance(node, ast.FunctionDef)
    ]

    self.solutions = [
        Solution(
            id=idx + 1,
            code=self._extract_code(f),
            docs=parse_method_docstring(ast.get_docstring(f, clean=True)),
            problem_statement=ast.get_docstring(class_definition[0], clean=True),
        )
        for idx, f in enumerate(method_definitions)
    ]

    return self.solutions
```

--------------------------------

### Export scraped data to CSV

Source: https://nikhil-ravi.github.io/LeetScrape/questions_list

Save the collected LeetCode data into multiple CSV files within a specified directory.

```python
ls.to_csv(directory="<dir>")
```

--------------------------------

### Scrape Question Data

Source: https://nikhil-ravi.github.io/LeetScrape/question

This method calls the Leetcode graphql api to query for the hints, companyTags, code snippets, and content of the question. It handles potential API errors and returns a structured Question object.

```APIDOC
## POST /api/question

### Description
This endpoint scrapes detailed information about a LeetCode question, including hints, company tags, code snippets, and the question content. It utilizes the LeetCode GraphQL API to fetch this data.

### Method
POST

### Endpoint
/api/question

### Parameters
#### Path Parameters
None

#### Query Parameters
- **titleSlug** (string) - Required - The unique slug of the LeetCode question to scrape.

#### Request Body
None

### Request Example
```json
{
  "titleSlug": "two-sum"
}
```

### Response
#### Success Response (200)
- **QuestionInfo** (object) - Contains the QID, titleSlug, Hints, Companies, Similar Questions, Code stubs, and the body of the question.

#### Response Example
```json
{
  "QID": "1",
  "title": "Two Sum",
  "titleSlug": "two-sum",
  "difficulty": "Easy",
  "Hints": [
    "The array is not sorted. If it were sorted, you could use two pointers.",
    "The naive approach is to iterate through the array twice. This would be O(n^2) time complexity.",
    "Can we do better? What if we store the numbers we've seen so far in a hash map?"
  ],
  "Companies": null, 
  "topics": [
    "Array",
    "Hash Table"
  ],
  "isPaidOnly": false,
  "Body": "Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target. You may assume that each input would have exactly one solution, and you may not use the same element twice. You can return the answer in any order.",
  "Code": "class Solution:\n    def twoSum(self, nums: list[int], target: int) -> list[int]:\n        pass",
  "SimilarQuestions": [2, 169, 170, 185, 2086]
}
```

### Error Handling
- **ValueError**: Raised when the connection to Leetcode’s graphql api is not established or if the API returns a 404 status code.
- **HTTP Error (429, 400)**: The API will retry the request after a delay if rate limiting or bad request errors occur.
```

--------------------------------

### GetQuestionsList class definition

Source: https://nikhil-ravi.github.io/LeetScrape/questions_list

The core class implementation for scraping LeetCode data and exporting it to CSV.

```python
class GetQuestionsList:
    """A class to scrape the list of questions, their topic tags, and company tags.

    Args:
        limit (int, optional): The maximum number of questions to query for from Leetcode's graphql API. Defaults to 10,000.
    """

    def __init__(self, limit: int = 10_000):
        self.limit = limit

    def scrape(self):
        """Scrapes LeetCode data including company tags, questions, question topics,
        and categories.
        """
        self._scrape_companies()
        self._scrape_questions_list()
        self._extract_question_topics()
        self._get_categories_and_topicTags_lists()
        self._scrape_question_category()
        self._add_category_to_questions_list()

    def to_csv(self, directory: str) -> None:
        """A method to export the scraped data into csv files in preparation for
        injection into a database.

        Args:
            directory (str): The directory path to export the scraped data into.
        """
        self.companies.to_csv(directory + "companies.csv", index=False)
        self.questions["QID"] = self.questions["QID"].astype(int)
        self.questions.to_csv(directory + "questions.csv", index=False)
        self.questionTopics.to_csv(
            directory + "questionTopics.csv", index=True, index_label="id"
        )
        self.categories.to_csv(directory + "categories.csv", index=False)
        self.topicTags.to_csv(directory + "topicTags.csv", index=False)
        self.questionCategory.to_csv(
            directory + "questionCategory.csv", index=True, index_label="id"
        )

    def _scrape_companies(self):
        """Scrape the company tags of each question. This always returns an empty
        dataframe as this is a paid only feature."""
        print("Scraping companies ... ", end="")
        data = {
            "query": """query questionCompanyTags {
                    companyTags {
                        name
                        slug
                        questionCount
                    }
                }
            """,
            "variables": {},
        }
        r = requests.post("https://leetcode.com/graphql", json=data).json()
```

--------------------------------

### Extract Front Matter from AST Module

Source: https://nikhil-ravi.github.io/LeetScrape/extract_solution

This method extracts front matter (metadata) from an Abstract Syntax Tree (AST) module. It looks for a variable with a specified name (defaulting to 'front_matter') and parses its content, expecting it to be a dictionary. It supports string values and lists of strings for the front matter fields.

```APIDOC
## _extract_front_matter(front_matter_name='front_matter')

### Description
Extracts the front matter from the given AST module.

### Method
GET

### Endpoint
/websites/nikhil-ravi_github_io_leetscrape/extract_front_matter

### Parameters
#### Query Parameters
- **front_matter_name** (str) - Optional - The name of the variable containing the front matter. Defaults to "front_matter".

### Raises
- **ValueError**: If the front_matter is not a dictionary.

### Returns
- **dict[str, str | list[str]]**: The extracted front matter as a dictionary.
```

--------------------------------

### Extract Question Topics

Source: https://nikhil-ravi.github.io/LeetScrape/questions_list

Creates an edge list DataFrame mapping questions to their respective topic tags.

```python
    def _extract_question_topics(self):
        """Create a table with the edge list of questions and topic tags."""
        print("Extracting question topics ... ", end="")
        self.questionTopics = (
            self.questions[["QID", "topicTags"]]
            .rename(columns={"topicTags": "tagSlug"})
            .explode("tagSlug", ignore_index=True)
        ).dropna()
        print("Done")
```

--------------------------------

### Generate code file content

Source: https://nikhil-ravi.github.io/LeetScrape/generate_code_stubs

Constructs the final file content by injecting front matter and the problem statement into the code stub.

```python
def _create_code_file(self) -> str:
        """Prepares the text to be written in the python file.

        Returns:
            str: The text to be written in the python file.
        """
        code_stub = self._get_code_stub()
        problem_statement = self._get_problem_statement()
        lines_to_write = []
        front_matter = {
            "qid": self.data.QID,
            "title": self.data.title,
            "titleSlug": self.data.titleSlug,
            "difficulty": self.data.difficulty,
            "tags": self.data.topics,
        }
        lines_to_write.append(f"front_matter = {front_matter}")
        lines_to_write.append(
            "# ====================== DO NOT EDIT ABOVE THIS LINE ======================"
        )
        for line in code_stub.split("\n"):
            lines_to_write.append(line)
            if line.startswith("class Solution"):
                lines_to_write.append(f'    """{problem_statement}"""')
            elif line.endswith(":") and not line.strip().startswith("#"):
                lines_to_write.append("        pass")
        lines_to_write.append(
            "    # If you have multiple solutions, add them all here as methods of the same class."
        )
        text_to_write = "\n".join(lines_to_write).replace("\n\n", "\n")
        return text_to_write
```

--------------------------------

### Extract Similar Questions

Source: https://nikhil-ravi.github.io/LeetScrape/question

Extracts the list of similar questions' QIDs from the API response. It uses a DataFrame to map title slugs to QIDs.

```python
def _get_similar_questions(self, response) -> list[int]:
    """A helper method to extract the list of similar questions of the
    given question.

    Returns:
        list[int]: The list of QIDs of the questions similar to the given question.
    """
    similar_questions = []
    for qs in json.loads(response["data"]["question"]["similarQuestions"]):
        similar_questions.append(self.questions_info.loc[qs["titleSlug"]].QID)
    return similar_questions
```

--------------------------------

### GenerateCodeStub class definition

Source: https://nikhil-ravi.github.io/LeetScrape/generate_code_stubs

The core class for scraping question data and generating local files. It requires either a titleSlug or qid to initialize.

```python
class GenerateCodeStub:
    """Class to generate the code stub and pytest test file for a Leetcode question. The class may be instantiated by either a question's QID or its titleSlug. It creates a code stub with the question's statement, constrainsts, and basic test cases in the docstring.

    It also creates a pytest test file from the basic test cases in the question body.

    Args:
        titleSlug (str, optional): The title slug of the question.
        qid (int, optional): The frontend question ID of the question.
    """

    def __init__(
        self,
        titleSlug: str | None = None,
        qid: int | None = None,
    ):
        self.all_questions_stub_id = (
            GetQuestion.fetch_all_questions_id_and_stub().reset_index().set_index("QID")
        )
        self.titleSlug = titleSlug
        self.qid = qid
        if self.titleSlug is None:
            if self.qid is None:
                raise ValueError(
                    "At least one of titleSlug or qid needs to be specified."
                )
            elif self.qid in self.all_questions_stub_id.index:
                self.titleSlug = self.all_questions_stub_id.loc[self.qid].titleSlug
            else:
                raise ValueError("There is no question with the passed qid")
        else:
            if self.titleSlug in self.all_questions_stub_id.titleSlug.tolist():
                if self.qid is not None:
                    if (
                        self.titleSlug
                        != self.all_questions_stub_id.loc[self.qid].titleSlug
                    ):
                        raise ValueError(
                            f"Both titleSlug and qid were passed but they do not match.\n"
                            + f"{self.qid}: {self.all_questions_stub_id.loc[self.qid].titleSlug}"
                        )
                else:
                    self.qid = self.all_questions_stub_id[
                        self.all_questions_stub_id["titleSlug"] == self.titleSlug
                    ].index[0]
            else:
                raise ValueError("There is no question with the passed titleSlug.")
        print(f"Generating code stub for {self.qid}. {self.titleSlug}")
        self.filename = f"q_{str(self.qid).zfill(4)}_{camel_case(self.titleSlug)}.py"
        questionInfoScraper = GetQuestion(titleSlug=self.titleSlug)
        self.data: Question = questionInfoScraper.scrape()

    def generate(self, testing=False, directory: str = ".") -> None:
        """Wrapper that creates the code stub and test files after formatting them through black.

        Args:
            testing (bool, optional): Whether we are in a testing environment. In testing environment, the files are not written to the disk. Defaults to False.
            directory (str, optional): The directory where the files are to be written. Defaults to ".".
        """
        if directory.endswith("/"):
```

--------------------------------

### to_csv(directory)

Source: https://nikhil-ravi.github.io/LeetScrape/questions_list

Exports the previously scraped data into multiple CSV files within a specified directory.

```APIDOC
## to_csv(directory)

### Description
A method to export the scraped data into csv files in preparation for injection into a database.

### Parameters
#### Path Parameters
- **directory** (str) - Required - The directory path to export the scraped data into.
```

--------------------------------

### Export Scraped Data to CSV

Source: https://nikhil-ravi.github.io/LeetScrape/questions_list

Exports the scraped LeetCode data into separate CSV files within a specified directory. This method prepares the data for database injection. Note the type casting for 'QID' and the use of index labels for specific dataframes.

```python
def to_csv(self, directory: str) -> None:
    """A method to export the scraped data into csv files in preparation for
    injection into a database.

    Args:
        directory (str): The directory path to export the scraped data into.
    """
    self.companies.to_csv(directory + "companies.csv", index=False)
    self.questions["QID"] = self.questions["QID"].astype(int)
    self.questions.to_csv(directory + "questions.csv", index=False)
    self.questionTopics.to_csv(
        directory + "questionTopics.csv", index=True, index_label="id"
    )
    self.categories.to_csv(directory + "categories.csv", index=False)
    self.topicTags.to_csv(directory + "topicTags.csv", index=False)
    self.questionCategory.to_csv(
        directory + "questionCategory.csv", index=True, index_label="id"
    )
```

--------------------------------

### Parse problem statement test cases

Source: https://nikhil-ravi.github.io/LeetScrape/generate_code_stubs

Utilities for extracting code blocks from markdown and parsing input/output parameters for test generation.

```python
def _extract_codeblocks_in_problem_statement(
        self, problem_statement: str
    ) -> list[str]:
        """Extract the code blocks from the given problem statement string. These codeblocks contain the basic test cases provided by Leetcode.

        Args:
            problem_statement (str): The problem statement with the code blocks

        Returns:
            list[str]: The list of code blocks. The length of list is equal to the number of basic test cases provided by Leetcode.
        """
        mk = marko.Markdown()
        markdown_text = mk.parse(problem_statement)
        code_blocks = [
            child.children[0].children
            for child in markdown_text.children
            if isinstance(child, marko.block.FencedCode)
        ]
        return code_blocks

    def _get_parameters(self, code_blocks: list[str]) -> tuple[str, str]:
        """Extract the inputs and outputs from each of the code block in the question body.

        Args:
            code_blocks (list[str]): The list of code block  in the question body.

        Returns:
            tuple[str, str]:
                - str: The input string to be added to the test file.
                - str: The output string to be added to the test file.
        """
        parameters = []
        for test in code_blocks:
            if "Input" in test:
                for line in test.split("\n"):
                    if line.startswith("Input:"):
                        inp = line.split("Input:")[1]
                parameter_dict = parse_args(inp)  # type: ignore
                parameter_dict["output"] = re.search(
                    "Output: (.*)\n",
                    test.replace("true", "True").replace(
                        "false", "False"
                    ),  # Leetcode uses true and false for True and False, respectively.
                )
                if parameter_dict["output"] is not None:
                    parameter_dict["output"] = parse_args(
```

--------------------------------

### Extract Leetcode API data

Source: https://nikhil-ravi.github.io/LeetScrape/generate_code_stubs

Methods to retrieve the raw code stub and convert the problem statement body into formatted markdown.

```python
def _get_code_stub(self) -> str:
        """Extracts the python code text from Leetcode's API response.

        Returns:
            str: The python code stub.
        """
        return self.data.Code

    def _get_problem_statement(self) -> str:
        """Extracts the python problem statement from Leetcode's API response.

        Returns:
            str: Te problem statement in markdown format.
        """
        # Because sup is non-standard markdown, we need to convert them to latex
        problem_statement = re.sub(r"<sup>(.*?)</sup>", r"^{\1}", self.data.Body)
        problem_statement_rst = md(problem_statement)
        return (
            problem_statement_rst.replace("**Input:**", "Input:")
            .replace("**Output:**", "Output:")
            .replace("**Explanation:**", "Explanation:")
        )
```
Tokens:
Raw