Refactor code base to isolate outputs and formatters

Author: johnsutor

.github/workflows/check-style.yml

@@ -0,0 +1,35 @@
+name: Style
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: ['ubuntu-latest']
+        python-version: ["3.10"]
+    runs-on: '${{ matrix.os }}'
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+    - name: Examine formatting with black 
+      run: |
+        pip install black
+        black . --check
+    - name: Examine import ordering with isort 
+      run: |
+        pip install isort
+        isort . --check --profile black

.github/workflows/python-app.yml .github/workflows/run-tests.yml.github/workflows/python-app.yml renamed to .github/workflows/run-tests.yml

@@ -34,15 +34,7 @@ jobs:
       run: |
         pip install mypy 
         mypy . --ignore-missing-imports --exclude /build/
-    - name: Test with pytest
+    - name: Test with pytest, ensuring 75% coverage
       run: |
         pip install pytest pytest-cov
-        pytest tests/ --doctest-modules --junitxml=junit/test-results.xml --cov=com --cov-report=xml --cov-report=html
-    - name: Examine formatting with black 
-      run: |
-        pip install black
-        black . --check
-    - name: Examine import ordering with isort 
-      run: |
-        pip install isort
-        isort . --check --profile black
+        pytest tests/ --cov --cov-fail-under=75

README.md

@@ -1,5 +1,6 @@
 # Leetcode Study Tool
 ![Tests Status](https://github.com/johnsutor/leetcode-study-tool/workflows/Tests/badge.svg)
+![Style Status](https://github.com/johnsutor/leetcode-study-tool/workflows/Style/badge.svg)
 [![Python Versions](https://img.shields.io/pypi/pyversions/leetcode-study-tool)](https://pypi.org/project/leetcode-study-tool/)
 [![PyPi](https://img.shields.io/pypi/v/leetcode-study-tool)](https://pypi.org/project/leetcode-study-tool/)
 ![contributions welcome](https://img.shields.io/badge/contributions-welcome-blue.svg?style=flat)
@@ -11,6 +12,9 @@ problems in a format that can be imported to Anki. These cards include three fie
 2. The publicly available solutions (and NeetCode solution, if available)
 3. The tags associated with the problem (i.e., if the problem involves a hash map, arrays, etc...)
 
+## Why? 
+This package was created as an opinionated alternative to other existing packages (as listed at the bottom of this README). 
+
 ## Installation
 ```shell
 $ pip install leetcode-study-tool
@@ -49,5 +53,11 @@ which will generate the file `output.txt`. We can then open Anki to import these
 - [ ] Add support for importing cards into Quizlet
 - [ ] Add support for fetching questions by topic or tag 
 - [ ] Add support for exporting to an excel sheet
-- [ ] Add support for showing neetcode solutions on the back of the card as a link
-- [ ] Reach 100% test coverage
+- [X] Add support for showing neetcode solutions on the back of the card as a link
+- [ ] Add support for determining which fields to show on the card 
+- [ ] Reach 90% test coverage
+
+## Other Usefull Stuff
+- [Remember anything with Anki](https://foggymountainpass.com/anki-essentials/)
+- [Leetcode Anki Card Generator](https://github.com/fspv/leetcode-anki)
+- [Leetcode API](https://github.com/fspv/python-leetcode)

leetcode_study_tool/cli.py

@@ -1,128 +1,6 @@
 import argparse
-import html
-import re
-from functools import partial
-from multiprocessing import Pool
-from typing import List, Union
 
-from .constants.leetcode_to_neetcode import LEETCODE_TO_NEETCODE
-from .queries import get_data, get_slug, get_url
-
-
-def sanitize(input: Union[str, list, None]) -> Union[str, list]:
-    """
-    Sanitize the given input to be Anki-compatible. This includes
-    removing delimeters with the desired Anki delimeter chosen
-    by the user.
-
-    Arguments
-    ---------
-    input : str
-        The input to sanitize.
-
-    Returns
-    -------
-    str
-        The sanitized input.
-    """
-    if input is None:
-        return ""
-    if isinstance(input, list):
-        return input
-    input = html.unescape(input)
-    input = re.sub(r"[;\n]", " ", input)
-    input = input.replace("</strong>", "</strong><br>")
-    input = re.sub(r"(<br>){2,}", "<br>", input)
-    return input
-
-
-def generate_solution_link(slug: str, solution_id: str) -> str:
-    """
-    Generate a link to the LeetCode solution with the given ID.
-
-    Arguments
-    ---------
-    slug : str
-        The slug of the question to generate a link for.
-    solution_id : str
-        The ID of the solution to generate a link for.
-
-    Returns
-    -------
-    str
-        The link to the LeetCode solution with the given ID.
-    """
-    return f"https://leetcode.com/problems/{slug}/solutions/{solution_id}/1/"
-
-
-def save_output(
-    problems: List[Union[str, None]], file: str, format: str = "cards"
-) -> None:
-    with open(file, "w") as f:
-        for problem in problems:
-            if problem:
-                f.write(problem + "\n")
-
-
-def generate_problem(
-    url: str, language: Union[str, None] = None, format: str = "cards"
-) -> Union[str, None]:
-    """
-    Generates a problem strings for the given URL in the requested format
-
-    Arguments
-    ---------
-    url : str
-        The URL of the question to generate a problem for.
-    language : str
-        The coding language to generate a problem for.
-
-    Returns
-    -------
-    str
-        The problem for the given URL.
-    """
-    url = url.strip()
-    if not url:
-        return None
-    slug = get_slug(url)
-    if language:
-        language = language.strip().lower()
-    try:
-        data = get_data(slug, language)
-    except Exception as e:
-        print(f"Failed to generate problem for {url}: {e}")
-        return None
-
-    data = {k: sanitize(v) for k, v in data.items()}
-
-    problem = (
-        f"<h1><a href=\"{get_url(url)}\">{data['id']}."
-        f" {data['title']}</a></h1>{data['content']}<br>"
-    )
-    if data["companies"]:
-        for company in data["companies"]:
-            problem += company["name"]
-    problem += "<ul>"
-    problem += "<strong>Tags:</strong><br>"
-    for tag in data["tags"]:
-        problem += f"<li>{tag['name']}</li>"
-    problem += "</ul>;"
-    problem += "<ul>"
-    if str(data["id"]) in LEETCODE_TO_NEETCODE:
-        neetcode = LEETCODE_TO_NEETCODE[str(data["id"])]
-        problem += "<strong>NeetCode Solution:</strong><br>"
-        problem += f"<a href=\"{neetcode['url']}\">{neetcode['title']}</a></li><br><br>"
-
-    problem += "<strong>LeetCode User Solutions:</strong><br>"
-
-    for solution in data["solutions"]:
-        solution_url = generate_solution_link(slug, solution["id"])
-        problem += f'<li><a href="{solution_url}">{solution_url}</a></li>'
-    problem += "</ul>;"
-    problem += " ".join([tag["slug"] for tag in data["tags"]])
-
-    return problem
+from leetcode_study_tool.creator import ProblemsCreator
 
 
 def parse_args() -> argparse.Namespace:
@@ -167,9 +45,16 @@ def parse_args() -> argparse.Namespace:
         "--format",
         "-F",
         type=str,
-        default="cards",
-        choices=["cards"],
-        help="The format to save the Anki problem(s) in.",
+        default="anki",
+        choices=["anki"],
+        help="The format to save the Leetcode problem(s) in.",
+    )
+
+    parser.add_argument(
+        "--csrf",
+        "-c",
+        type=str,
+        help="The CSRF token to use for LeetCode authentication.",
     )
 
     parser.add_argument(
@@ -190,28 +75,10 @@ def parse_args() -> argparse.Namespace:
     return parser.parse_args()
 
 
-def cli(args: argparse.Namespace):
-    """
-    Handles the multi-processing of problem generation.
-    """
-    if args.url:
-        urls = args.url.split(",")
-    elif args.file:
-        with open(args.file, "r") as f:
-            urls = f.read().splitlines()
-
-    with Pool() as pool:
-        problems = pool.map(
-            partial(generate_problem, language=args.language),
-            urls,
-        )
-
-    save_output(problems, args.output, args.format)
-
-
 def main():
     args = parse_args()
-    cli(args)
+    creator = ProblemsCreator(args)
+    creator.create_problems()
 
 
 if __name__ == "__main__":

leetcode_study_tool/creator.py

@@ -0,0 +1,120 @@
+import argparse
+import html
+import os
+import re
+from functools import partial
+from multiprocessing import Pool
+from typing import List, Union
+
+from .formatters import FORMAT_MAP
+from .outputs import SAVE_MAP
+from .queries import generate_session, get_data, get_slug
+
+
+class ProblemsCreator:
+    """
+    Create problems for Anki from the CLI inputs.
+    """
+
+    def __init__(self, args: Union[argparse.Namespace, dict]) -> None:
+        # Explicitly define for linting
+        self.format = "anki"
+        self.output = "output"
+
+        args = vars(args)
+        for key in args:
+            setattr(self, key, args[key])
+
+        if args.get("language"):
+            self.language = args["language"].strip().lower()
+        else:
+            self.language = None
+
+        if args.get("csrf"):
+            self.session = generate_session(args["csrf"])
+        else:
+            self.session = generate_session()
+
+        if args.get("url"):
+            self.urls = args["url"].split(",")
+
+        elif args.get("file"):
+            with open(args["file"], "r") as f:
+                self.urls = f.read().splitlines()
+
+    def create_problems(self) -> None:
+        """
+        Create the problems for Anki.
+        """
+        with Pool() as pool:
+            problems = pool.map(
+                partial(
+                    self._generate_problem,
+                    language=self.language,
+                    format=self.format,
+                ),
+                self.urls,
+            )
+
+        self._save_output(problems, self.output)
+
+    def _sanitize(self, input: Union[str, list, None]) -> Union[str, list]:
+        """
+        Sanitize the given input to be Anki-compatible. This includes
+        removing delimeters with the desired Anki delimeter chosen
+        by the user.
+
+        Arguments
+        ---------
+        input : str
+            The input to sanitize.
+
+        Returns
+        -------
+        str
+            The sanitized input.
+        """
+        if input is None:
+            return ""
+        if isinstance(input, list):
+            return input
+        input = html.unescape(input)
+        input = re.sub(r"[;\n]", " ", input)
+        input = input.replace("</strong>", "</strong><br>")
+        input = re.sub(r"(<br>){2,}", "<br>", input)
+        return input
+
+    def _save_output(self, problems: List[Union[str, None]], file: str) -> None:
+        file_name = os.path.splitext(os.path.basename(file))[0]
+
+        SAVE_MAP[self.format](problems, file_name)
+
+    def _generate_problem(self, url: str) -> Union[str, None]:
+        """
+        Generates a problem strings for the given URL in the requested format
+
+        Arguments
+        ---------
+        url : str
+            The URL of the question to generate a problem for.
+        language : str
+            The coding language to generate a problem for.
+
+        Returns
+        -------
+        str
+            The problem for the given URL.
+        """
+        url = url.strip()
+        if not url:
+            return None
+        slug = get_slug(url)
+        try:
+            data = get_data(slug, self.language, self.session)
+        except Exception as e:
+            print(f"Failed to generate problem for {url}: {e}")
+            return None
+
+        data = {k: self._sanitize(v) for k, v in data.items()}
+
+        return FORMAT_MAP[self.format](url, slug, data)