many more changes and fixes, add api methods to package root

Author: Rajdave69

pybpsapi/__init__.py

@@ -0,0 +1,9 @@
+from .main import *
+
+
+_default_api = API()
+
+latest = _default_api.latest
+list = _default_api.list
+search = _default_api.search
+getpng = _default_api.getpng

pybpsapi.py renamed to pybpsapi/main.py

@@ -107,44 +107,46 @@ def getpng(self, url: str) -> list | None:
 
 
 class CircularChecker:
-    def __init__(self, category: str | int = None, url: str = "https://bpsapi.rajtech.me/", cache_method: str = 'sqlite', **kwargs):
-        self.url = url
+    def __init__(
+            self, category: str | int = None,
+            api_url: str = "https://bpsapi.rajtech.me/",
+            fallback_api_url: str = None,
+            cache_method: str = 'pickle', **kwargs
+    ):
+        self.api_url = api_url
+        self.fallback_api_url = fallback_api_url
         self.category = category
         self.cache_method = cache_method
-        self.latest_circular_id = self.get_cache()
 
         # Get category names from API
-        json = requests.get(self.url + "categories").json()
+        categories = self._send_api_request("categories")
 
-        if json['http_status'] == 200:
-            categories = json['data']
-        else:
-            raise ConnectionError("Invalid API Response. API says there are no categories.")
-
-        # If category id is passed
+        # If this circular checker is supposed to be for a specific category of circulars only
+        # Check if the category name or id is valid
         if category is not None:
             if type(self.category) is int:
                 if not _min_category_id <= self.category:
                     raise ValueError("Invalid category Number")
             else:   # If category name is passed
                 if self.category not in categories:
-                    raise ValueError("Invalid category Name")
+                    raise ValueError(f"Invalid category Name ({self.category})."
+                                     f"Allowed are {categories}")
 
+        # Check if all required variables for each cache method are passed in kwargs
+        # And create a pickle file or database file on disk (sqlite) if it doesn't exist
         # For the sqlite cache method
         if self.cache_method == "sqlite":
             try:
-                self.db_name = kwargs['db_name']
                 self.db_path = kwargs['db_path']
                 self.db_table = kwargs['db_table']
             except KeyError:
                 raise ValueError(
                     "Invalid Database Parameters. One of db_name, db_path, db_table not passed into kwargs")
 
             # Create local db if it does not exist
-            if not os.path.exists(self.db_path + f"/{self.db_name}.db"):
+            if not os.path.exists(self.db_path):
                 os.mkdir(self.db_path)
 
-
         # For the mysql/mariadb cache method
         elif cache_method == "mysql":
             try:
@@ -159,37 +161,53 @@ def __init__(self, category: str | int = None, url: str = "https://bpsapi.rajtec
                 raise ValueError(
                     "Invalid Database Parameters. One of db_name, db_user, db_host, db_port, db_password, db_table not passed into kwargs")
 
+        # For the pickle cache method
         elif cache_method == 'pickle':
             try:
                 self.cache_file = kwargs['cache_file']
             except KeyError:
                 raise ValueError("Invalid cache file path")
 
+            if not os.path.exists(self.cache_file):
+                with open(self.cache_file, 'wb') as f:
+                    f.write(b'')
+
         else:
             raise ValueError("Invalid cache method. Only mysql and sqlite allowed")
 
-        # Create a table to cache circulars if it's not there
+        # For sqlite and mysql, create a table if it doesn't exist in the database
         if self.cache_method in ('sqlite', 'mysql'):
             con, cur = self._get_db()
 
             cur.execute(
                 f"""
             CREATE TABLE IF NOT EXISTS  {self.db_table}  (
-                category	TEXT,
-                id	INTEGER UNIQUE,
-                title	TEXT,
-                link	TEXT
+                category	VARCHAR(15) PRIMARY KEY,
+                latest_circular_id	INTEGER
             )
             """
             )
             con.commit()
             con.close()
 
-        # If cache method is pickle, create a file if it doesn't exist
-        elif self.cache_method == 'pickle':
-            if not os.path.exists(self.cache_file):
-                with open(self.cache_file, 'wb') as f:
-                    f.write(b'')
+        if self.get_cache() is None:
+            self.check()
+
+    def _send_api_request(self, endpoint: str, fallback=False) -> dict:
+        try:
+            api_url = self.fallback_api_url if fallback else self.api_url
+            request = requests.get(api_url + endpoint, timeout=5)
+            json = request.json()
+        except requests.exceptions.ConnectionError:
+            if fallback:
+                raise ConnectionError("Both API URLs are down")
+            if self.fallback_api_url:
+                warnings.warn("API is down. Trying fallback API URL")
+                return self._send_api_request(endpoint, True)
+            else:
+                raise ConnectionError("API is down")
+
+        return json['data']
 
     def _get_db(self):
         if self.cache_method == 'mysql':
@@ -216,45 +234,100 @@ def get_cache(self) -> int | None:
             cur.execute(f"SELECT latest_circular_id FROM {self.db_table} WHERE category = ?", (self.category,))
             res = cur.fetchone()
 
+            if res is not None:
+                res = res[0]
+
         elif self.cache_method == 'pickle':
             with open(self.cache_file, 'rb') as f:
                 res = pickle.load(f)
+        else:
+            raise ValueError("Method not supported for this cache method")
+
+        if res is not None:
+            res = int(res)
 
         return res
 
-    # Method to add multiple items to cache
     def _set_cache(self, circular_id: int):
 
         if self.cache_method in ('sqlite', 'mysql'):
             con, cur = self._get_db()
-            query = f"INSERT OR IGNORE INTO {self.db_table} (category, latest_circular_id) VALUES (?, ?)"
+            # cur.execute(f"DELETE FROM {self.db_table} WHERE category = ?", (self.cate))
 
-            if self.cache_method == 'mysql':
-                query = query.replace("OR ", "")
+            query = f"REPLACE INTO {self.db_table} (category, latest_circular_id) VALUES (?, ?)"
 
             cur.execute(query, (self.category, circular_id,))
             con.commit()
 
         elif self.cache_method == 'pickle':
             with open(self.cache_file, 'wb') as f:
-                pickle.dumps(circular_id, f)
+                f.write(pickle.dumps(circular_id))
 
 
-    # Method to check for new circular(s)
+    # Method to check for new circulars
     def check(self) -> list[dict] | list:
-        res = requests.get(self.url + f"new-circulars/{self.latest_circular_id}").json()['data']
+
+        if cache := self.get_cache() is not None:
+            res = self._send_api_request(f'new-circulars/{cache}')
+        else:
+            res = self._send_api_request('new-circulars/')
         # it's sorted in descending order
 
+        # If the API found new circulars
         if len(res) > 0:
             self._set_cache(res[0]['id'])
 
+            # If this circular-checker is meant for only one category,
+            # remove circulars of any other category
             if self.category:
                 res = [circular for circular in res if circular['category'] == self.category]
 
+                # remove the 'category' key from each of the circular objects
+                for circular in res:
+                    del circular['category']
         return res
 
 
     # Close connections when object is deleted
-    def __del__(self):
-        pass
-
+    # def __del__(self):
+    #
+    #     if hasattr(self, '_con'):
+    #         self._con.close()
+
+
+class CircularCheckerGroup:
+    def __init__(self, *circular_checkers: CircularChecker):
+        self._checkers = []
+
+        # Add each checker to self._checkers
+        for checker in circular_checkers:
+            if type(checker) is not CircularChecker:
+                raise ValueError("Invalid CircularChecker Object")
+            self._checkers.append(checker)
+
+
+    # Method to add a circular checker to this group
+    def add(self, checker: CircularChecker, *circular_checkers: CircularChecker):
+        self._checkers.append(checker)
+
+        for checker in circular_checkers:
+            if type(checker) is not CircularChecker:
+                raise ValueError("Invalid CircularChecker Object")
+            self._checkers.append(checker)
+
+    # Method to create a circular checker and add it to the group
+    def create(self, category, url: str = "https://bpsapi.rajtech.me/", cache_method=None, **kwargs):
+        checker = CircularChecker(category, url, cache_method, **kwargs)
+        self._checkers.append(checker)
+
+    # Method to check for new circulars in each one of the checkers
+    def check(self) -> dict[list[dict], ...] | dict:
+        return_dict = {}
+        for checker in self._checkers:
+            return_dict[checker.category] = checker.check()
+        return return_dict
+
+    #
+    # def __del__(self):
+    #     for checker in self._checkers:
+    #         del checker