Cache keeps a cache of its cache to cache for later caching

Author: intendednull

src/cache.py

@@ -2,26 +2,29 @@
 import requests
 import time
 import multiprocessing as mp
+
+from typing import List, Text
 from random import randint, choice, sample
 
 from . import API
 
 
 class ImageCache:
-    '''Class used for caching images'''
+    """Class used for caching images"""
 
     ratelimit = 0.05
     with API.open() as fp:
         api = json.load(fp)
 
+    api_cache = {
+        'info': None,
+        'hobbies': None
+    }
+
     def __init__(self, size):
-        self.manager = mp.Manager()
-        self.queue = self.manager.Queue(size)
+        self.queue = mp.Queue(size)
         self.worker = None
 
-        self.infocache = None
-        self.hobbycache = None
-
     def __del__(self):
         self.stop()
 
@@ -31,60 +34,54 @@ def __get(self, url, **kwargs):
         except ConnectionError as e:
             return e
 
-    def __parse_image(self, data: dict):
-        data = response.json()
+    def __parse_image(self, data: List[dict]) -> dict:
         url = data[0]['url']
         response = self.__get(url)
         return {'image': response.content}
 
-    def __parse_hobbies(self, response):
-        all_hobbies = response.text.split("\n")
-        return {'hobbies': sample(all_hobbies, 5)}
+    def __parse_hobbies(self, data: Text):
+        return {'hobbies': sample(data, 5)}
 
-    def __parse_info(self, response):
-        data = response.json()
+    def __parse_info(self, data: dict):
         letter = choice('acdefghijklmnopqrstuvwxyz')
         data = choice(data[letter])
         return {
+            'name': data['name'],
             'info': {
-                'name': data['name'],
                 'gender': data['gender'],
                 'age': randint(1, 42),
                 'location': f'{randint(1, 9999)} miles away'
             }
         }
 
     def get_profile(self):
-        api = [self.api['image']]
-        if self.infocache is None:
-            api.append(self.api['info'])
-        if self.
-
-        with mp.Pool(poolsize) as pool:
-            response = pool.map(self.__get, self.api.values())
-        if ConnectionError not in responses:  # TODO Record connection errors
+        response = {k: self.__get(v) for k, v in self.api.items() if self.api_cache.get(k) is None}
+        if ConnectionError not in response:  # TODO Record connection errors
+            if 'info' in response:
+                self.api_cache['info'] = response['info'].json()
+            if 'hobbies' in response:
+                self.api_cache['hobbies'] = response['hobbies'].text.split('\n')
             return {
-                **self.__parse_info(response['info']),
-                **self.__parse_image(response['image']),
-                **self.__parse_hobbies(response['hobbies'])
+                **self.__parse_info(self.api_cache['info']),
+                **self.__parse_hobbies(self.api_cache['hobbies']),
+                **self.__parse_image(response['image'].json())
             }
 
-    def next(self):
-        return self.queue.get()
-
     def mainloop(self, queue):
         while True:
             profile = self.get_profile()
             if profile is not None:
                 queue.put(profile)
             time.sleep(self.ratelimit)
 
+    def next(self):
+        return self.queue.get()
+
     def start(self):
         if self.worker is not None and self.worker.is_alive():
             self.stop()
         self.worker = mp.Process(target=self.mainloop, args=(self.queue,))
         self.worker.start()
 
     def stop(self):
-        for worker in mp.active_children():
-            worker.terminate()
+        self.worker.terminate()

src/front.py

@@ -22,7 +22,7 @@ class Front(widget.PrimaryFrame):
     # doesn't delete it before the animation ends
     _last = None
 
-    def __next(self):
+    def __next(self, direction: Direction = None):
         data: dict = self.cache.next()
         image = process_image(
             data.pop('image'),
@@ -31,6 +31,10 @@ def __next(self):
         )
         name = data.pop('name')
         self.__load(name, image, data)
+        if direction is None:
+            self.window.set_view(self.image)
+        else:
+            self.window.change_view(self.image, direction)
 
     def __load(self, name, image, data):
         self.title.config(text=name)
@@ -41,10 +45,6 @@ def __load(self, name, image, data):
         self.bio.data.load(data)
         self.update()
 
-    def __change_image(self, direction: Direction):
-        self.__next()
-        self.window.change_view(self.image, direction)
-
     def init(self):
         self.title = widget.PrimaryLabel(self)
         self.window = Window(self)
@@ -71,33 +71,24 @@ def init(self):
         self.btn_like.pack(side='left')
 
         self.cache = ImageCache(self.cachesize)
+        self.cache.start()
+        # Prime the pump
+        self.after_idle(self.__next)
 
     def cmd_dislike(self):
-        self.__change_image('left')
+        self.__next('left')
 
     def cmd_like(self):
-        self.__change_image('right')
+        self.__next('right')
 
     def cmd_bio(self):
         if self.window.current != self.bio:
             self.window.change_view(self.bio, 'up')
         else:
             self.window.change_view(self.image, 'down')
 
-    @property
-    def cache(self):
-        return self._cache
-
-    @cache.setter
-    def cache(self, imagecache: ImageCache):
-        self._cache = imagecache
-        self._cache.start()
-        # Prime the pump
-        self.__next()
-        self.window.set_view(self.image)
-
     def cleanup(self):
-        self._cache.stop()
+        self.cache.stop()
 
 
 class Bio(widget.PrimaryFrame):