class restructurization

Author: Coderbeep

leetcode/main.py

@@ -16,6 +16,7 @@
 # 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)
+# TODO: check the changes in question_content and apply them to the code in other files
 
 def positive_integer(value):
     try:

leetcode/models/graphql_problemset_question_list.py

@@ -1,5 +1,9 @@
 from leetcode.models import *
 
+""" This module contains the QueryTemplate class for the problemsetQuestionList query. 
+    The class is used to fetch a list of LeetCode problems by the 'list' command.
+    """
+
 @dataclass
 class QueryResult(JSONWizard):
     @dataclass
@@ -53,44 +57,53 @@ class ProblemsetQuestionList(QueryTemplate):
             - 'difficulty' (str, optional): Difficulty level. Valid values: 'EASY', 'MEDIUM', 'HARD'.
             - 'status' (str, optional): Status of the problem. Valid values: 'NOT_STARTED', 'TRIED', 'AC'.
         limit (int, optional): Maximum number of problems to retrieve. Defaults to None.
+            If not provided, the value is taken from the user config file.
         skip (int, optional): Number of problems to skip. Defaults to 0.
     """
 
     def __init__(self, filters={}, limit=None, skip=0):
         super().__init__()
-
         # Instance specific variables
         self.page : int = 1
         self.max_page : int = 0
         self.filters = filters
         self.limit = limit or self.config.user_config.get('question_list_limit')
         self.skip = skip
+        self._data_fetched: bool = False
 
-        self.params = {'categorySlug': "", 
+        self._params = {'categorySlug': "", 
                        'skip':self.skip, 
                        'limit': self.limit, 
                        'filters': self.filters}
-        
-        self.graphql_query = None
-        self.result = None
+
+        self.data = None
 
     def fetch_data(self, parameters: Dict = None) -> QueryResult:
-        """ Fetches the data from the LeetCode API.
+        """ Fetches the data from the LeetCode API. 
+            Updates the state of the object.
 
         Args:
             parameters (dict, optional): Parameters to pass to the query. Defaults to None.
 
         Returns:
             QueryResult: The result of the query.
         """
-
-        if parameters is None:
-            parameters = self.params
-        with Loader('Fetching problems...', ''):
-            self.graphql_query = GraphQLQuery(self.query, parameters)
-            self.result = self.leet_API.post_query(self.graphql_query) # Take the response from the API
-            self.result = QueryResult.from_dict(self.result['data'])
-        return self.result
+        try: 
+            with Loader('Fetching problems...', ''):
+                if parameters is not None and parameters != self.params:
+                    self.params = parameters
+                
+                if self.data_fetched:
+                    return self.data
+            
+                self.graphql_query = GraphQLQuery(self.query, parameters)
+                self.data = self.leet_API.post_query(self.graphql_query) # Take the response from the API
+                self.data = QueryResult.from_dict(self.data['data'])
+                self.data_fetched = True
+                return self.data
+        except Exception as e:
+            console.print(f"{e.__class__.__name__}: {e}", style=ALERT)
+            sys.exit(1)
 
     def _execute(self, args):
         """ Executes the query with the given arguments and displays the result.
@@ -100,32 +113,31 @@ def _execute(self, args):
         """
 
         self.__parse_args(args)
-        self.result = self.fetch_data()
-        self.show(self.result)
+        self.data = self.fetch_data()
+        self.show(self.data)
 
-    def show(self, query_result: Optional[QueryResult] = None) -> None:
+    def show(self) -> None:
         """ Displays the query result in a table.
 
         Args:
             query_result (QueryResult, optional): The result of the query. Defaults to None.
                 If the result is None, the method will try to fetch the data with defauly parameters and than display it.
         """
-
-        if query_result is None:
-            query_result = self.fetch_data()
-        
-        displayed : int = self.limit * self.page if self.limit * self.page < query_result.total else self.result.total
-        
-        table = LeetTable(title=f'Total number of problems retrieved: {query_result.total}\n',
-                            caption=f"Page #{self.page} / ({displayed}/{self.result.total})")
-        
-        table.add_column('ID')
-        table.add_column('Title')
-        table.add_column('Status')
-        table.add_column('Difficulty')
-        for item in query_result.questions:
-            table.add_row(item.questionId, item.title, item.status, item.difficulty)
-        console.print(table)
+        if self.data_fetched:   
+            displayed : int = self.limit * self.page if self.limit * self.page < self.data.total else self.data.total
+            
+            table = LeetTable(title=f'Total number of problems retrieved: {self.data.total}\n',
+                                caption=f"Page #{self.page} / ({displayed}/{self.data.total})")
+            
+            table.add_column('ID')
+            table.add_column('Title')
+            table.add_column('Status')
+            table.add_column('Difficulty')
+            for item in self.data.questions:
+                table.add_row(item.questionId, item.title, item.status, item.difficulty)
+            console.print(table)
+        else:
+            raise Exception("Data is not fetched yet.")
 
     def __validate_page(self):
         """ Validates the current page number.
@@ -160,4 +172,21 @@ def __parse_args(self, args):
         self.page = getattr(args, 'page') 
         self.params['skip'] = self.limit * self.page - self.limit
 
-        self.__validate_page()
+        self.__validate_page()
+        
+    @property
+    def data_fetched(self):
+        return self._data_fetched
+    
+    @data_fetched.setter
+    def data_fetched(self, data_fetched: bool):
+        self._data_fetched = data_fetched
+    
+    @property
+    def params(self):
+        return self._params
+    
+    @params.setter
+    def params(self, params: dict):
+        self._params = params
+        self.data_fetched = False

leetcode/models/graphql_question_content.py

@@ -4,9 +4,9 @@ class QuestionContent(QueryTemplate):
     """ A class to represent a LeetCode problem content. 
     
     Args:
-        title_slug (str): The title slug of the problem. """
+        title_slug (str, optional): The title slug of the problem. If provided the data is fetched when the object is created. Defaults to None."""
 
-    def __init__(self, title_slug):
+    def __init__(self, title_slug: str = None):
         super().__init__()
         # Instance-specific variables
         self._title_slug = title_slug
@@ -15,36 +15,36 @@ def __init__(self, title_slug):
         self._data_fetched: bool = False
 
         self.question_panels: List[rich.panel.Panel] = []
-        self.fetch_data(self.title_slug)
+        
+        if title_slug is not None:
+            self.fetch_data(self.title_slug)
 
     def fetch_data(self, title_slug: str = None) -> Dict:
         """ Fetches the content data for the problem.
         
         Args:
-            parameters (dict, optional): Parameters to pass to the query. Defaults to None.
+            title_slug (str, optional): The title slug of the problem. Defaults to None.
             
         Returns:
             Dict: The content data for the problem.
         """
         try:
             with Loader('Fetching question details...', ''):
-                parameters = self.params
-                if title_slug is None:
-                    parameters = self.params
-                elif title_slug != self.title_slug:
+                # If provided title slug does not change anything, return the data
+                if title_slug is not None and title_slug != self.title_slug:
                     self.title_slug = title_slug
-                    self.params = {'titleSlug': title_slug}
-                    parameters = self.params
+
                 if self.data_fetched:
-                    return self._data
+                    return self.data
 
-                graphql_query = GraphQLQuery(self.query, parameters)
+                graphql_query = GraphQLQuery(self.query, self.params)
                 response = self.leet_API.post_query(graphql_query)
+                
                 if response['data']['question'] is None:
                     raise Exception('There is no question with title slug: ' + title_slug)
+                
                 self.data = response['data']['question']['content']
                 self.data_fetched = True
-                self.params = parameters
                 return self.data
         except Exception as e:
             console.print(f"{e.__class__.__name__}: {e}", style=ALERT)
@@ -121,7 +121,7 @@ def data_fetched(self, data_fetched: bool):
 
 
 if __name__ == '__main__':
-    content = QuestionContent('two-sumfsdf')
+    content = QuestionContent('two-sum')
     print(content)
     content.fetch_data('add-two-integers')
     print(content)

leetcode/models/graphql_question_info_table.py

@@ -33,38 +33,37 @@ class QuestionInfoTable(QueryTemplate):
     
     Args:
         titleSlug (str): The title slug of the question to fetch data for.
+            If provided the data is fetched when the object is created. Defaults to None.
     """
 
-    def __init__(self, titleSlug):
+    def __init__(self, title_slug: str = None):
         super().__init__()
         # Instance-specific variables
-        self._title_slug = titleSlug
+        self._title_slug = title_slug
         self._data = None
-        self._params = {'titleSlug': titleSlug}
+        self._params = {'titleSlug': title_slug}
         self._data_fetched: bool = False
 
-        self.fetch_data(self.title_slug)
+        if title_slug is not None:
+            self.fetch_data(self.title_slug)
 
-    def fetch_data(self, titleSlug: str = None) -> Dict:
+    def fetch_data(self, title_slug: str = None) -> Dict:
         try:
             with Loader('Fetching question details...', ''):
-                parameters = self.params
-                if titleSlug is None:
-                    parameters = self.params
-                elif titleSlug != self.title_slug:
-                    self.title_slug = titleSlug
-                    self.params = {'titleSlug': titleSlug}
-                    parameters = self.params
+                if title_slug is not None and title_slug != self.title_slug:
+                    self.title_slug = title_slug
+                
                 if self.data_fetched:
-                    return self._data
+                    return self.data
 
-                graphql_query = GraphQLQuery(self.query, parameters)
+                graphql_query = GraphQLQuery(self.query, self.params)
                 response = self.leet_API.post_query(graphql_query)
+                
                 if response['data']['question'] is None:
-                    raise Exception('There is no question with title slug: ' + titleSlug)
+                    raise Exception('There is no question with title slug: ' + title_slug)
+                
                 self.data = Question.from_dict(response['data'])
                 self.data_fetched = True
-                self.params = parameters
                 return self.data
         except Exception as e:
             console.print(f"{e.__class__.__name__}: {e}", style=ALERT)

leetcode/models/graphql_question_of_today.py

@@ -43,8 +43,23 @@ def __init__(self):
         self.title_slug: str = None
 
         self.data = None
+        
+    def fetch_data(self) -> Dict:
+        """ Fetches the question of the day data.
+
+        Returns:
+            Dict: The question of the day data.
+        """
+        try:
+            with Loader('Fetching question of the day...', ''):
+                graphql_query = GraphQLQuery(self.query, {})
+                response = self.leet_API.post_query(graphql_query)
+                return response['data']
+        except Exception as e:
+            console.print(f"{e.__class__.__name__}: {e}", style=ALERT)
+            sys.exit(1)
 
-    def _execute(self, args):
+    def _execute(self, args) -> None:
         """ Executes the query with the given arguments and displays the result.
 
         Args:
@@ -59,7 +74,7 @@ def _execute(self, args):
             self.title_slug = self.data.question.titleSlug
         self.show()
 
-    def show(self):
+    def show(self) -> None:
         """ Shows the question information and content or opens the question in a browser. 
         The displayed information depends on the flags passed to the command line.
         """
@@ -77,7 +92,7 @@ def show(self):
         else:
             print(question_info_table)
 
-    def __parse_args(self, args):
+    def __parse_args(self, args) -> None:
         """ Parses the command line arguments.
 
         Args:

leetcode/models/graphql_submission_list.py

@@ -36,12 +36,33 @@ def __init__(self):
         super().__init__()
         # Instance specific variables
         self.question_id: int = None
-        self.show_terminal = False
-        self.submission_download = False
+        self.show_terminal: bool = False
+        self.submission_download: bool = False
 
-        self.graphql_query = None
         self.data = None  
         self.params = {'offset': 0, 'limit': 20, 'lastKey': None, 'questionSlug': None}
+        
+    def fetch_data(self, question_id: int = None) -> Dict:
+        """ Fetches the submission list data for the problem.
+
+        Args:
+            question_id (int, optional): The question id of the problem. Defaults to None.
+            
+        Returns:
+            Dict: The submission list data for the problem.
+        """
+        try:
+            with Loader('Fetching submission list...', ''):
+                if question_id is not None and question_id != self.question_id:
+                    self.question_id = question_id
+                    self.params['questionSlug'] = ProblemInfo.get_title_slug(self.question_id)
+                
+                graphql_query = GraphQLQuery(self.query, self.params)
+                response = self.leet_API.post_query(graphql_query)
+                return response['data']
+        except Exception as e:
+            console.print(f"{e.__class__.__name__}: {e}", style=ALERT)
+            sys.exit(1)
 
     def _execute(self, args):
         """ Executes the query with the given arguments and displays the result.