refactored the main processes

qlist.py

@@ -9,27 +9,58 @@ def buildtorlist(self):
             torrent = self.torrentlist.pop()
             if self.use_log:
                 self.tl.debug(f'["{torrent["name"][0:20]}..."] {torrent["infohash_v1"]}')
-            if torrent['added_on'] + self.minimum_age >= self.t.time():
+            # if torrent['added_on'] + self.minimum_age >= self.t.time():
+            if ispreme(torrent['added_on'], self.minimum_age, self.t.time()):
                 self.preme_tor_counter += 1
                 continue
-            if torrent['category'] in self.cat_whitelist.values():
+            # if torrent['category'] in self.cat_whitelist.values():
+            if iscatignored(torrent['category'], self.cat_whitelist.values()):
                 self.tl.info(f'Ignored torrent:["{torrent["name"][0:20]}..."]')
                 self.ignored_counter += 1
                 continue
-            if torrent['tracker'] == '':
+            # if torrent['tracker'] == '':
+            if istrackerblank(torrent['tracker']):
                 if self.use_log:
                     self.tl.warning(f'Torrent doesn\'t have a tracker ["{torrent["name"][0:20]}..."] [{torrent["tracker"]}]hash: {torrent["hash"]}')
                 self.ignored_counter += 1
                 continue
-            if torrent['tracker'].split('/')[2] in self.tracker_whitelist.values():
+            # if torrent['tracker'].split('/')[2] in self.tracker_whitelist.values():
+            if isprotectedtracker(torrent['tracker'], self.tracker_whitelist.values()):
                 if self.use_log:
                     self.tl.debug(f'Protected torrent: {torrent["tracker"]}hash: {torrent["hash"]}')
-                if torrent['tags'] == '':
+                # if torrent['tags'] == '':
+                if istagblank(torrent['tags']):
                     self.qbt_client.torrents_add_tags(self.tracker_protected_tag,torrent['hash'])
                 self.tracker_list.append(torrent)
-            if torrent['tracker'].split('/')[2] not in self.tracker_whitelist.values():
+            if isnotprotectedtracker(torrent['tracker'], self.tracker_whitelist.values()):
                 if self.use_log:
                     self.tl.debug(f'Non-protected torrent: {torrent["tracker"]}hash: {torrent["hash"]}')
-                if torrent['tags'] == '':
+                # if torrent['tags'] == '':
+                if istagblank(torrent['tags']):
                     self.qbt_client.torrents_add_tags(self.tracker_non_protected_tag,torrent['hash'])
-                self.tracker_list.append(torrent)
+                self.tracker_list.append(torrent)
+
+def ispreme(added, minage, time):
+    if added + minage >= time:
+        return True
+
+def iscatignored(cat, catlist):
+    if cat in catlist:
+        return True
+
+def istrackerblank(tracker):
+    if tracker == '':
+        return True
+
+def isprotectedtracker(tracker, trackerlist):
+    if tracker.split('/')[2] in trackerlist:
+        return True
+
+def isnotprotectedtracker(tracker, trackerlist):
+    if tracker.split('/')[2] not in trackerlist:
+        return True
+
+def istagblank(tag):
+    if tag == '':
+        return True
+    

qprocess.py

@@ -3,30 +3,36 @@ def torprocessor(self):
     If torrent meets criteria for deletion, its infohash_v1 will be appended to self.torrent_hash_delete_list
     """
     for canidate in self.tracker_list:
-        if canidate['state'] == 'downloading':
+        # if canidate['state'] == 'downloading':
+        if isdownloading(canidate['state']):
             if self.use_log:
                 self.tl.info(f'["{canidate["name"][0:20]}..."] is still downloading and will be skipped.')
             continue
-        elif canidate['ratio'] < float(1.05) and self.tracker_protected_tag in canidate["tags"]:
+        # elif canidate['ratio'] < float(1.05) and self.tracker_protected_tag in canidate["tags"]:
+        elif isprotectedunderratio(canidate['ratio'], 1.05, self.tracker_protected_tag, canidate["tags"]):
             if self.use_log:
                 self.tl.debug(f'["{canidate["name"][0:20]}..."] is below a 1.05 ratio({canidate["ratio"]})')
-            if canidate['added_on'] + self.age <= self.t.time():
+            # if canidate['added_on'] + self.age <= self.t.time():
+            if isoldtor(canidate['added_on'], self.age, self.t.time()):
                 if self.use_log:
                     self.tl.debug(f'["{canidate["name"][0:20]}..."] Seconds old: {self.t.time() - self.age - canidate["added_on"]}')
                 self.torrent_hash_delete_list.append(canidate['infohash_v1'])
                 if self.use_log:
                     self.tl.info(f'Submitted ["{canidate["name"][0:20]}..."] for deletion from the protected list.') 
-        elif canidate['ratio'] >= float(1.05) and self.tracker_protected_tag in canidate["tags"]:
+        # elif canidate['ratio'] >= float(1.05) and self.tracker_protected_tag in canidate["tags"]:
+        elif isprotectedoverratio(canidate['ratio'], 1.05, self.tracker_protected_tag, canidate["tags"]):
             if self.use_log:
                 self.tl.debug(f'["{canidate["name"][0:20]}..."] is above a 1.05 ratio({canidate["ratio"]}).')  
             self.torrent_hash_delete_list.append(canidate['infohash_v1'])
             if self.use_log:
                 self.tl.info(f'Submitted ["{canidate["name"][0:20]}..."] for deletion from the protected list.')
-        elif self.tracker_non_protected_tag in canidate["tags"]:
+        # elif self.tracker_non_protected_tag in canidate["tags"]:
+        elif isnonprotectedtor(self.tracker_non_protected_tag, canidate["tags"]):
             self.torrent_hash_delete_list.append(canidate['infohash_v1'])
             if self.use_log:   
                 self.tl.info(f'Submitted ["{canidate["name"][0:20]}..."] for deletion.')
         else:
+            dragnet(self, canidate['state'],canidate['ratio'],canidate["tags"],canidate['added_on'],self.age,self.t.time(),canidate['infohash_v1'],canidate["name"][0:20])
             self.tl.info(f'["{canidate["name"][0:20]}..."] is orphaned.')
             self.up_tor_counter += 1
             continue
@@ -41,4 +47,27 @@ def tordelete(self):
     if self.use_log:
         self.tl.debug('Hash list submitted for deletion:')
         self.tl.debug(self.torrent_hash_delete_list)
-    self.qbt_client.torrents_delete(True, self.torrent_hash_delete_list)
+    self.qbt_client.torrents_delete(True, self.torrent_hash_delete_list)
+
+def isdownloading(state):
+    if state == 'downloading':
+        return True
+
+def isprotectedunderratio(torratio, setratio, settag, tortag):
+    if torratio < float(setratio) and settag in tortag:
+        return True
+
+def isoldtor(toradd, setage, currenttime):
+    if toradd + setage <= currenttime:
+        return True
+
+def isprotectedoverratio(torratio, setratio, settag, tortag):
+    if torratio >= float(setratio) and settag in tortag:
+        return True
+
+def isnonprotectedtor(setnonprotectedtag, tortags):
+    if setnonprotectedtag in tortags:
+        return True
+
+def dragnet(self,state,ratio,tags,added,age,time,thash,tname):
+    pass

test_qbitmaid.py

@@ -1,18 +1,56 @@
 import unittest
-from qprocess import torprocessor
+from qlist import ispreme,iscatignored,istrackerblank,isprotectedtracker
-import json
-import logging
-import sys
-class TestQprocess(unittest.TestCase):
-    def test_log_and_test_data(self):
-        self.log= logging.getLogger( "SomeTest.testSomething" )
-        self.tracker_list = open("./test/torrentinfo.txt", "r")
-        self.log.debug(self.tracker_list)
-        assert self.tracker_list
-        
-        # torprocessor(self)    
 
+class TestQbitmaid(unittest.TestCase):
+    def test_ispreme_sanity(self):
+        self.assertTrue(ispreme(1,1,1))
+        self.assertFalse(ispreme(1,1,3))
+    
+    def test_ispreme(self):
+        pass
+
+    def test_iscatignored_sanity(self):
+        self.assertTrue(iscatignored('a', ['a','b','c']))
+        self.assertTrue(iscatignored('b', ['a','b','c']))
+        self.assertTrue(iscatignored('c', ['a','b','c']))
+        self.assertFalse(iscatignored('d', ['a','b','c']))
+        self.assertFalse(iscatignored(1, ['a','b','c']))
+        self.assertFalse(iscatignored(1.0000000, ['a','b','c']))
+
+    def test_iscatignored(self):
+        pass
+
+    def test_istrackerblank_sanity(self):
+        self.assertTrue(istrackerblank(''))
+        self.assertFalse(istrackerblank('a'))
+        self.assertFalse(istrackerblank(1))
+        self.assertFalse(istrackerblank(1.00000000))
+
+    def test_istrackerblank(self):
+        pass
+
+    def test_isprotectedtracker_sanity(self):
+        self.assertTrue(isprotectedtracker('https://a.com/',['a.com','b.me','c.io']))
+        self.assertFalse(isprotectedtracker('https://google.com/',['a.com','b.me','c.io']))
+        self.assertFalse(isprotectedtracker('https://d.com',['a.com','b.me','c.io']))
+
+    def test_isprotectedtracker(self):
+        pass
+
+    def test_isnotprotectedtracker_sanity(self):
+        pass
+
+    def test_isnotprotectedtracker(self):
+        pass
+
+    def test_istagblank(self):
+        pass
+
+    def test_(self):
+        pass
+    
+    def test_(self):
+        pass
+        
 if __name__ == '__main__':
-    logging.basicConfig( stream=sys.stderr )
-    logging.getLogger( "SomeTest.testSomething" ).setLevel( logging.DEBUG )
     unittest.main()