submission command

Author: Coderbeep

leetcode/loader.py

@@ -31,7 +31,7 @@ def _animate(self):
         for c in cycle(self.steps):
             if self.done:
                 break
-            print(f"\r{self.desc} {c}", flush=True, end="")
+            print(f"\r{c} {self.desc}", flush=True, end="")
             sleep(self.timeout)
 
     def __enter__(self):
@@ -41,7 +41,7 @@ def stop(self):
         self.done = True
         cols = get_terminal_size((80, 20)).columns
         print("\r" + " " * cols, end="", flush=True)
-        print(f"\r{self.end}", flush=True)
+        print(f"\r{self.end}", flush=True, end="")
 
     def __exit__(self, exc_type, exc_value, tb):
         # handle exceptions with those variables ^

leetcode/main.py

@@ -2,15 +2,12 @@
 from leetcode.models import *
 from leetcode.configuration import check_session_validity, UserConfig
 
-# IDEA: submit the code to the proper question
-# using the question slug and question ID that needs to be contained within the filename
-
-# the file can be generated when the user displsays the question
-
 # TODO: pipes support
 # TODO: add a command to open the question in editor
 # TODO: add a command to show the solution in the terminal
 # TODO: add a command to show the solution in the browser
+# TODO: problem with import in synced code or code to submit
+# TODO: random problem selector (from not accepted problems)
 
 def positive_integer(value):
     try:
@@ -54,10 +51,11 @@ def main():
     today_problem_parser = subparsers.add_parser('today', help="Display today's problem.")
     today_problem_parser.set_defaults(func=QuestionOfToday)
 
-    # submission_parser = subparsers.add_parser('submission', help="Download submission code")
-    # submission_parser.add_argument('question_slug', type=str, help='Title slug of the problem.')
-    # submission_parser.add_argument('-l', '--list', action='store_true', help='List all submissions.')
-    # submission_parser.set_defaults(func=submissionList)
+    submission_parser = subparsers.add_parser('submission', help="Download submission code")
+    submission_parser.add_argument('id', type=int, help='ID of the problem.')
+    submission_parser.add_argument('-s', '--show', action='store_true', help='Show latest accepted code in the terminal.')
+    submission_parser.add_argument('-d', '--download', action='store_true', help='Download the latest accepted code.')
+    submission_parser.set_defaults(func=SubmissionList)
 
     submission_parser = subparsers.add_parser('submit', help='Submit code answer')
     submission_parser.add_argument('question_slug', type=str, help="Title slug of the question")

leetcode/models/__init__.py

@@ -24,7 +24,7 @@
 from leetcode.models.graphql_question_info_table import QuestionInfoTable
 from leetcode.models.graphql_question_of_today import QuestionOfToday
 from leetcode.models.graphql_submission_details import SubmissionDetails
-from leetcode.models.graphql_submission_list import SubmissionList
 from leetcode.models.graphql_user_problems_solved import UserProblemsSolved
 from leetcode.models.problem_by_id_slug import ProblemInfo
+from leetcode.models.graphql_submission_list import SubmissionList
 from leetcode.models.submit import SendSubmission

leetcode/models/graphql_submission_list.py

@@ -28,36 +28,49 @@ def from_dict(cls, data):
         return cls(submissions=submissions)
 
 
+
+# TODO: Emojis/colors for status display (Accepted, Wrong Answer, Runtime Error)
+# TODO: Handle empty submissions table
 class SubmissionList(QueryTemplate):
     def __init__(self):
         super().__init__()
         # Instance specific variables
-        self.question_slug = ""
-        self.list_view = False
+        self.question_id: int = None
+        self.show_terminal = False
         self.submission_download = False
 
         self.graphql_query = None
         self.result = None  
-        self.params = {'offset': 0, 'limit': 20, 'lastKey': None, 'questionSlug': ""}
+        self.params = {'offset': 0, 'limit': 20, 'lastKey': None, 'questionSlug': None}
 
     def parse_args(self, args):
-        self.params['questionSlug'] = args.question_slug
-        if args.list:
-            self.list_view = True
-        else:
+        self.question_id = args.id
+        self.params['questionSlug'] = ProblemInfo.get_title_slug(self.question_id)
+        
+        if getattr(args, 'show'):
+            self.show_terminal = True
+            
+        if getattr(args, 'download'):
             self.submission_download = True
 
     def execute(self, args):
-        self.parse_args(args)
-        
-        self.graphql_query = GraphQLQuery(self.query, self.params)
-        self.result = self.leet_API.post_query(self.graphql_query)
-        self.result = QuestionSubmisstionList.from_dict(self.result['data'])
-        if self.list_view:
+        try:
+            with Loader('Fetching submission list...', ''):
+                self.parse_args(args)
+                self.graphql_query = GraphQLQuery(self.query, self.params)
+                self.result = self.leet_API.post_query(self.graphql_query)
+                self.result = QuestionSubmisstionList.from_dict(self.result['data'])
+                if not self.result.submissions:
+                    raise ValueError("Apparently you don't have any submissions for this problem.")
             self.show()
-        if self.submission_download:
-            print(self.get_code())
-    
+            
+            if self.show_terminal:
+                self.show_code()
+
+            if self.submission_download:
+                self.download_submission()
+        except Exception as e:
+            console.print(f"{e.__class__.__name__}: {e}", style=ALERT)
 
     def show(self):
         table = LeetTable()
@@ -72,9 +85,55 @@ def show(self):
         for x in submissions:
             table.add_row(x.id, x.title, x.statusDisplay, x.runtime, x.memory, x.langName)
         console.print(table)
+        
+    
+    @staticmethod
+    def fetch_accepted(submissions):
+        return next((x for x in submissions if x.statusDisplay == 'Accepted'), None)
 
-    def get_code(self):
-        # TODO: returning the code of the first submission for now
-        submission_details = SubmissionDetails(self.result.submissions[0].id)
-        submission_details.execute()
-        return submission_details.result.code
+    def show_code(self):
+        try:
+            with Loader('Fetching latest accepted code...', ''):
+                acc_submission = self.fetch_accepted(self.result.submissions)
+                
+                if not acc_submission:
+                    raise ValueError("No accepted submissions found.")
+                
+                submission_id = acc_submission.id
+                
+                query = self.parser.extract_query('SubmissionDetails')
+                params = {'submissionId': submission_id}
+                graphql_query = GraphQLQuery(query, params)
+                result = self.leet_API.post_query(graphql_query)
+                
+                code = result['data']['submissionDetails']['code']
+                
+            console.print(rich.rule.Rule('Latest accepted code', style='bold blue'), width=100)
+            console.print(rich.syntax.Syntax(code, 'python', theme='monokai', line_numbers=True), width=100)
+        except Exception as e:
+            console.print(f"{e.__class__.__name__}: {e}", style=ALERT)
+        
+    def download_submission(self):
+        try:
+            with Loader('Downloading latest accepted code...', ''):
+                acc_submission = self.fetch_accepted(self.result.submissions)
+            
+                if not acc_submission:
+                    raise ValueError("No accepted submissions found.")
+
+                query = self.parser.extract_query('SubmissionDetails')
+                params = {'submissionId': acc_submission.id}
+                graphql_query = GraphQLQuery(query, params)
+                result = self.leet_API.post_query(graphql_query)
+                
+                code = result['data']['submissionDetails']['code']
+                file_name = f"{acc_submission.titleSlug}.{acc_submission.id}.py"
+                with open(file_name, 'w') as file:
+                    file.write(code)
+                    
+            console.print(f"File saved as {file_name}")
+        except Exception as e:
+            console.print(f"{e.__class__.__name__}: {e}", style=ALERT)
+            
+        
+        

two-sum.1008758093.py

@@ -0,0 +1,10 @@
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        seen_numbers = {}
+        for index, number in enumerate(nums):
+            complement = target - number
+            if complement in seen_numbers:
+                return [index, seen_numbers[complement]] 
+            else:
+                seen_numbers[number] = index
+        return None