cobweb-launcher 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

cobweb/db/redis_db.py

@@ -151,17 +151,19 @@ class RedisDB:
     @check_redis_status
     def check_spider_queue(self, stop, storer_num):
         while not stop.is_set():
-            # 每15s获取check锁,等待600s后仍获取不到锁则重试;获取到锁后，设置锁的存活时间为15s
+            # 每15s获取check锁,等待600s后仍获取不到锁则重试;获取到锁后，设置锁的存活时间为${cs_lct}s
             if self._get_lock(key=self.check_lock, t=self.cs_lct, timeout=600, sleep_time=3):
                 heartbeat = True if self.client.exists(self.heartbeat_key) else False
-                # 重启重制score值，否则获取n分钟前的分数值
+                # 重启重制score值，否则获取${rs_time}分钟前的分数值
                 score = -int(time.time()) + self.rs_time if heartbeat else "-inf"
 
                 keys = self.client.keys(self.storer_key % "*")
+
                 if keys and len(keys) >= storer_num:
                     intersection_key = self.storer_key % "intersection"
                     self.client.delete(intersection_key)
                     self.client.zinterstore(intersection_key, keys)
+
                     while True:
                         members = self.client.zrange(intersection_key, 0, 1999)
                         if not members:
@@ -192,7 +194,7 @@ class RedisDB:
                     self.client.setex(self.heartbeat_key, 15, "")
 
                 # self.client.delete(self.check_lock)
-                time.sleep(3)
+                # time.sleep(3)
 
     @check_redis_status
     def set_heartbeat(self, stop):

cobweb/distributed/launcher.py

@@ -1,50 +1,15 @@
 import time
 import threading
 from threading import Thread
-from importlib import import_module
 
-from cobweb import log, Queue, DBItem, RedisDB, OssDB, StorerInterface
-from cobweb.utils import struct_queue_name, restore_table_name
-from cobweb.setting import MODEL, RESET_SCORE, CHECK_LOCK_TIME
 from .models import Scheduler, Spider, Storer
-
-
-def get_scheduler_db(db):
-    if isinstance(db, str):
-        if "." in db:
-            model_path = db.split(".")
-            model = import_module(db)
-            obj = getattr(model, db)
-        else:
-            model = import_module(f"cobweb.db.scheduler.{db.lower()}")
-            obj = getattr(model, db.capitalize())
-        return obj
-        # if db.lower() in dir(StorerDB):
-        #     return getattr(StorerDB, db)
-        # else:
-        #     pass
-    elif issubclass(db, StorerInterface):
-        return db
-    raise TypeError()
-
-
-def get_storer_db(db):
-    if isinstance(db, str):
-        if "." in db:
-            model_path = db.split(".")
-            model = import_module(db)
-            obj = getattr(model, db)
-        else:
-            model = import_module(f"cobweb.db.storer.{db.lower()}")
-            obj = getattr(model, db.capitalize())
-        return obj, db.lower()
-        # if db.lower() in dir(StorerDB):
-        #     return getattr(StorerDB, db)
-        # else:
-        #     pass
-    elif issubclass(db, StorerInterface):
-        return db, db.__name__.lower()
-    raise TypeError()
+from cobweb import log, Queue, DBItem, RedisDB
+from cobweb.setting import MODEL, RESET_SCORE, CHECK_LOCK_TIME
+from cobweb.utils import (
+    struct_queue_name as sqn,
+    restore_table_name as rtn,
+    parse_import_model as pim,
+)
 
 
 def check(stop, last, spider, scheduler, storer_list, ready_seed_length, spider_queue_length):
@@ -164,9 +129,9 @@ def launcher(task):
         size = task.scheduler_info.get("size")
         scheduler_config = task.scheduler_info.get("config")
         scheduler_db = task.scheduler_info.get("db", "default")
-        DB = get_scheduler_db(scheduler_db)
+        DB, class_name = pim(scheduler_db, "scheduler")
         # SchedulerDB, table, sql, length, size, config = task.scheduler_info
-        SchedulerTmp = type(DB.__name__, (Scheduler, DB), {})
+        SchedulerTmp = type(class_name, (Scheduler, DB), {})
 
         # 初始化调度器
         scheduler = SchedulerTmp(
@@ -185,18 +150,16 @@ def launcher(task):
         # new item
         item = type("Item", (object,), {"redis_client": redis_db.client})()
 
-        if task.oss_config:
-            item.oss = OssDB(**task.oss_config)
-
         for storer_info in storer_info_list:
             storer_db = storer_info["db"]
             fields = storer_info["fields"]
             storer_table = storer_info.get("table", "console")
             storer_config = storer_info.get("config")
 
-            StorerDB, db_name = get_storer_db(storer_db)
-            StorerTmp = type(StorerDB.__name__, (Storer, StorerDB), {})
+            StorerDB, class_name = pim(storer_db, "storer")
+            StorerTmp = type(class_name, (Storer, StorerDB), {})
 
+            db_name = class_name.lower()
             if not getattr(item, db_name, None):
                 instance = type(db_name, (DBItem,), {})
                 setattr(item, db_name, instance)
@@ -204,10 +167,10 @@ def launcher(task):
             storer_item_instance = getattr(item, db_name)
             storer_item_instance.init_item(storer_table, fields)
 
-            storer_queue = struct_queue_name(db_name, storer_table)
+            storer_queue = sqn(db_name, storer_table)
             queue = getattr(storer_item_instance, storer_queue)
             # 初始话存储器
-            table_name = restore_table_name(table_name=storer_table)
+            table_name = rtn(table_name=storer_table)
             storer = StorerTmp(
                 table=table_name, fields=fields,
                 length=task.storer_queue_length,

cobweb/distributed/models.py

@@ -1,6 +1,8 @@
 import time
 from hashlib import md5
-from cobweb import log, Queue, Seed, StorerInterface, SchedulerInterface
+from cobweb import log, Queue, Seed
+from utils import issubclass_cobweb_interface
+
 # from pympler import asizeof
 
 
@@ -8,7 +10,8 @@ class Scheduler:
 
     def schedule_seed(self, ready_seed_length, get_scheduler_lock, add_seed):
 
-        if not issubclass(self.__class__, SchedulerInterface):
+        inf_name = "SchedulerInterface"
+        if not issubclass_cobweb_interface(self.__class__, inf_name):
             raise Exception("not have schedule function!")
 
         if self.__class__.__name__ == "Default":
@@ -103,7 +106,8 @@ class Storer:
 
     def store_task(self, stop, last, reset_seed, set_storer):
 
-        if not issubclass(self.__class__, StorerInterface):
+        inf_name = "StorerInterface"
+        if not issubclass_cobweb_interface(self.__class__, inf_name):
             return None
 
         if not getattr(self, "store", None):

cobweb/single/launcher.py

@@ -0,0 +1,231 @@
+import time
+import threading
+from threading import Thread
+
+from .models import Scheduler, Spider, Storer
+from cobweb import log, Queue, DBItem, RedisDB
+from cobweb.setting import MODEL, RESET_SCORE, CHECK_LOCK_TIME
+from cobweb.utils import (
+    struct_queue_name as sqn,
+    restore_table_name as rtn,
+    parse_import_model as pim,
+)
+
+
+def check(stop, last, spider, scheduler, storer, ready_seed_length, spider_queue_length):
+    log.info("run check thread after 30 seconds...")
+    time.sleep(30)
+    spider_info = """
+------------------- check: {0} ------------------
+            redis_spider_seed_length:  {1}
+            redis_ready_seed_length:   {2}
+            running_spider_thread_num: {3}
+            memory_seed_queue_length:  {4}
+            storer_queue_length_info:  {5}
+-----------------------  end  -----------------------"""
+    while True:
+        status = "running"
+        running_spider_thread_num = spider.spider_in_progress.length
+        redis_ready_seed_length = ready_seed_length()
+        redis_spider_seed_length = spider_queue_length()
+        memory_seed_queue_length = scheduler.queue.length
+        storer_upload_queue_length = storer.queue.length
+        if (
+                scheduler.stop and
+                # not redis_ready_seed_length and
+                not memory_seed_queue_length and
+                not running_spider_thread_num
+        ):
+            if not MODEL:
+                log.info("spider is done?")
+            last.set()
+            time.sleep(3)
+            storer_queue_empty = True
+            if storer.queue.length:
+                storer_queue_empty = False
+            storer_upload_queue_length = storer.queue.length
+            if (
+                    storer_queue_empty and
+                    not redis_ready_seed_length and
+                    not redis_spider_seed_length
+            ):
+                if MODEL:
+                    log.info("waiting for push seeds...")
+                    status = "waiting"
+                    time.sleep(30)
+                else:
+                    log.info("spider done!")
+                    break
+
+            last.clear()
+
+        log.info(spider_info.format(
+            status,
+            redis_spider_seed_length,
+            redis_ready_seed_length,
+            running_spider_thread_num,
+            memory_seed_queue_length,
+            storer_upload_queue_length
+        ))
+
+        time.sleep(3)
+    stop.set()
+
+
+def launcher(task):
+    """
+    任务启动装饰器
+    :param task: 任务配置信息
+    """
+    def decorator(func):
+        """
+        Item:
+            Textfile()
+            Loghub()
+            Console()
+        e.g.
+        task.fields = "a,b"
+        func(item, seed)
+            a = "a"
+            b = "b"
+            data = {"a": "a", "b": "b"}
+            yield item.Loghub(**data)
+            yield item.Loghub(a=a, b=b)
+        """
+        storer_list = []
+
+        # 程序结束事件
+        last = threading.Event()
+        # 停止采集事件
+        stop = threading.Event()
+
+        # 初始化redis信息
+        redis_db = RedisDB(
+            task.project, task.task_name, task.redis_info,
+            model=MODEL, cs_lct=CHECK_LOCK_TIME, rs_time=RESET_SCORE
+        )
+
+        # new item
+        item = type("Item", (object,), {"redis_client": redis_db.client})()
+
+        log.info("初始化cobweb!")
+
+        seed_queue = Queue()
+
+        scheduler_info = task.scheduler_info or dict()
+
+        # 调度器动态继承
+        sql = scheduler_info.get("sql")
+        table = scheduler_info.get("table")
+        size = scheduler_info.get("size")
+        scheduler_config = scheduler_info.get("config")
+        scheduler_db = scheduler_info.get("db", "default")
+        DB, class_name = pim(scheduler_db, "scheduler")
+        # SchedulerDB, table, sql, length, size, config = task.scheduler_info
+        SchedulerTmp = type(class_name, (Scheduler, DB), {})
+
+        # 初始化调度器
+        scheduler = SchedulerTmp(
+            table=table, sql=sql, size=size, queue=seed_queue,
+            length=task.scheduler_queue_length, config=scheduler_config
+        )
+
+        # 初始化采集器
+        spider = Spider(seed_queue, task.max_retries)
+
+        storer = None
+
+        # 解析存储器信息
+        storer_info = task.storer_info or dict()
+
+        # for storer_info in storer_info_list:
+        if storer_info:
+            storer_db = storer_info["db"]
+            fields = storer_info["fields"]
+            storer_table = storer_info.get("table", "console")
+            storer_config = storer_info.get("config")
+
+            StorerDB, class_name = pim(storer_db, "storer")
+            StorerTmp = type(class_name, (Storer, StorerDB), {})
+
+            db_name = class_name.lower()
+            if not getattr(item, db_name, None):
+                instance = type(db_name, (DBItem,), {})
+                setattr(item, db_name, instance)
+
+            storer_item_instance = getattr(item, db_name)
+            storer_item_instance.init_item(storer_table, fields)
+
+            storer_queue = sqn(db_name, storer_table)
+            queue = getattr(storer_item_instance, storer_queue)
+            # 初始话存储器
+            table_name = rtn(table_name=storer_table)
+            storer = StorerTmp(
+                table=table_name, fields=fields,
+                length=task.storer_queue_length,
+                queue=queue, config=storer_config
+            )
+
+        Thread(target=redis_db.check_spider_queue, args=(stop, len(storer_list))).start()
+        Thread(target=redis_db.set_heartbeat, args=(stop,)).start()
+
+        # 推送初始种子
+        # seeds = start_seeds(task.start_seed)
+        redis_db.add_seed(task.seeds)
+        # 启动调度器, 调度至redis队列
+        Thread(
+            # name="xxxx_schedule_seeds",
+            target=scheduler.schedule_seed,
+            args=(
+                redis_db.ready_seed_length,
+                redis_db.get_scheduler_lock,
+                redis_db.add_seed
+            )
+        ).start()
+
+        # 启动调度器, 调度任务队列
+        Thread(
+            # name="xxxx_schedule_task",
+            target=scheduler.schedule_task,
+            args=(
+                stop, redis_db.get_seed,
+                redis_db.ready_seed_length
+            )
+        ).start()
+
+        # 启动采集器
+        for index in range(task.spider_num):
+            Thread(
+                # name=f"xxxx_spider_task:{index}",
+                target=spider.spider_task,
+                args=(
+                    stop, func, item,
+                    redis_db.del_seed
+                )
+            ).start()
+
+        # 启动存储器
+        if storer:
+            Thread(
+                # name=f"xxxx_store_task:{storer.table}",
+                target=storer.store_task,
+                args=(
+                    stop, last,
+                    redis_db.reset_seed,
+                    redis_db.set_storer
+                )
+            ).start()
+
+        Thread(
+            # name="check_spider",
+            target=check,
+            args=(
+                stop, last, spider,
+                scheduler, storer,
+                redis_db.ready_seed_length,
+                redis_db.spider_queue_length,
+            )
+        ).start()
+
+    return decorator
+

cobweb/single/models.py

@@ -1,104 +1,136 @@
 import time
-# from pympler import asizeof
-from single.nest import Queue
-from single.nest import struct_queue_name
-from single.nest import SchedulerInterface, StorerInterface
-
-
-# class Transceiver:
-class Distributor:
-
-    def __init__(self):
-        self.seed_queue = Queue()
+from cobweb import log, Queue, Seed
+from utils import issubclass_cobweb_interface
 
-    @property
-    def queue_names(self):
-        return tuple(self.__dict__.keys())
+# from pympler import asizeof
 
-    @property
-    def used_memory(self):
-        return asizeof.asizeof(self)
 
-    def create_queue(self, queue_name: str):
-        self.__setattr__(queue_name, Queue())
+class Scheduler:
 
-    def get_queue(self, queue_name: str):
-        return self.__getattribute__(queue_name)
+    def schedule_seed(self, ready_seed_length, get_scheduler_lock, add_seed):
 
-    def deal_item(self, item):
-        icn = item.__class__.__name__
-        if icn == "Seed":
-            self.seed_queue.push(item)
-        elif getattr(item, "table_name", None):
-            queue_name = struct_queue_name(icn, item.table_name)
-            getattr(self, queue_name).push(item.serialization)
+        inf_name = "SchedulerInterface"
+        if not issubclass_cobweb_interface(self.__class__, inf_name):
+            raise Exception("not have schedule function!")
 
-    def distribute(self, callback, *args, **kwargs):
-        iterable = callback(*args, **kwargs)
-        if not iterable:
+        if self.__class__.__name__ == "Default":
+            self.stop = True
             return None
-        for result in iterable:
-            self.deal_item(result)
-        return True
-
 
-class Scheduler:
+        while not self.stop:
+            length = ready_seed_length()
+            if length > self.size:
+                time.sleep(15)
 
-    def schedule_task(self, distribute):
+            elif get_scheduler_lock():
+                seeds = self.schedule()
+                add_seed(seeds)
 
-        if not issubclass(self.__class__, SchedulerInterface):
-            return None
+        log.info(f"close thread: schedule_seed")
 
-        if not getattr(self, "schedule", None):
-            raise Exception("not have schedule function!")
+    def schedule_task(self, stop, get_seed, ready_seed_length):
+        time.sleep(3)
+        while not stop.is_set():
 
-        while not self.stop:
+            if not ready_seed_length():
+                time.sleep(15)
+                continue
 
-            if self.queue.length < self.length:
-                distribute(self.schedule)
+            if self.queue.length >= self.length:
+                time.sleep(3)
+                continue
 
-            else:
-                print("------------")
-                time.sleep(15)
+            seeds = get_seed(self.length)
+            self.queue.push(seeds)
+        log.info(f"close thread: schedule_task")
 
 
 class Spider:
 
-    def __init__(self, queue):
-        self.queue = queue
+    def __init__(self, queue, max_retries=5):
         self.spider_in_progress = Queue()
+        self.max_retries = max_retries
+        self.queue = queue
 
-    def spider_task(self, stop_event, distribute, func, item):
-        while not stop_event.is_set():
+    def spider_task(self, stop, func, item, del_seed):
+        while not stop.is_set():
             seed = self.queue.pop()
             if not seed:
                 time.sleep(3)
                 continue
+            elif seed._retry >= self.max_retries:
+                del_seed(seed, spider_status=False)
+                continue
             try:
-                self.spider_in_progress.push(1)
-                distribute(func, item, seed)
+                self.spider_in_progress.push(1, direct_insertion=True)
+                # log.info("spider seed: " + str(seed))
+                status = None
+                for it in func(item, seed):
+                    if getattr(it, "table_name", None):
+                        store_queue = it.queue()
+                        store_queue.push(
+                            [seed, it.struct_data],
+                            direct_insertion=True
+                        )
+                    elif isinstance(it, Seed):
+                        self.queue.push(it)
+                    elif any(isinstance(it, t) for t in (list, tuple)):
+                        self.queue.push([s if isinstance(s, Seed) else Seed(s) for s in it])
+                    elif isinstance(it, bool):
+                        status = it
+                    elif it is None:
+                        status = False
+
+                if status is not None:
+                    if status:
+                        del_seed(seed, spider_status=True)
+                    else:
+                        seed._retry += 1
+                        self.queue.push(seed)
+
             except Exception as e:
-                print(e)
+                seed._retry += 1
+                self.queue.push(seed)
+                log.info(f"{str(seed)} -> {str(e)}")
             finally:
                 self.spider_in_progress.pop()
+        log.info(f"close thread: spider")
 
 
 class Storer:
 
-    def store_task(self, stop_event, last_event, distribute):
+    def store_task(self, stop, last, reset_seed, del_seed):
 
-        if not issubclass(self.__class__, StorerInterface):
+        inf_name = "StorerInterface"
+        if not issubclass_cobweb_interface(self.__class__, inf_name):
             return None
 
         if not getattr(self, "store", None):
             raise Exception("not have store function!")
 
-        while not stop_event.is_set():
-            if last_event.is_set() or self.queue.length > self.length:
-                data_list = []
-                data_length = min(self.queue.length, self.length)
-                for _ in range(data_length):
-                    data = self.queue.pop()
+        storer_name = self.__class__.__name__ + self.table
+
+        while not stop.is_set():
+
+            if last.is_set() or self.queue.length >= self.length:
+                seeds, data_list = [], []
+
+                for _ in range(self.length):
+                    items = self.queue.pop()
+                    if not items:
+                        break
+                    seed, data = items
+                    seeds.append(seed)
                     data_list.append(data)
+
                 if data_list:
-                    distribute(self.store, data_list)
+                    if self.store(data_list):
+                        del_seed(seeds)
+                    else:
+                        reset_seed(seeds)
+                        log.info("reset seeds!")
+                    continue
+
+            time.sleep(3)
+
+        log.info(f"close thread: {storer_name}")

cobweb/utils.py

@@ -1,11 +1,9 @@
 import json
+import re
 import sys
+from abc import ABC
 from typing import Iterable
-
-import requests
-
-
-# from cobweb import Seed
+from importlib import import_module
 
 
 def struct_table_name(table_name):
@@ -20,27 +18,6 @@ def struct_queue_name(db_name, table_name):
     return sys.intern(f"__{db_name}_{table_name}_queue__")
 
 
-# class StorerDB:
-#
-#     @staticmethod
-#     def console(self):
-#         from db.storer.console import Console
-#         table = struct_table_name(table)
-#         return StorerInfo(DB=Console, table=table, length=length, config=None)
-#
-#     @staticmethod
-#     def textfile(table, length=200):
-#         from db.storer.textfile import Textfile
-#         table = struct_table_name(table)
-#         return StorerInfo(DB=Textfile, table=table, length=length, config=None)
-#
-#     @staticmethod
-#     def loghub(table, length=200, config=None):
-#         from db.storer.loghub import Loghub
-#         table = struct_table_name(table)
-#         return StorerInfo(DB=Loghub, table=table, length=length, config=config)
-
-
 def parse_info(info):
     if not info:
         return info
@@ -74,15 +51,40 @@ def struct_start_seeds(seeds):
         return Seed(seeds)
 
 
-# def get_storer_db(db):
-#
-#     if isinstance(db, str):
-#         model = import_module(f" db.storer.{db.lower()}")
-#
-#         # if db.lower() in dir(StorerDB):
-#         #     return getattr(StorerDB, db)
-#         # else:
-#         #     pass
-
+def issubclass_cobweb_interface(_class, inf_name):
+    for _c in _class.__mro__[1:]:
+        if _c.__name__ == inf_name:
+            return True
+    return False
+
+
+def parse_import_model(model_info, model_type=None):
+    if model_type not in ["scheduler", "storer"]:
+        raise TypeError("model_type must be in scheduler, storer")
+    if isinstance(model_info, str):
+        if "import" in model_info:
+            model_path, class_name = re.search(
+                r"from (.*?) import (.*?)$", model_info
+            ).groups()
+            model = import_module(model_path)
+            class_object = getattr(model, class_name)
+        elif "." in model_info:
+            info_list = model_info.split(".")
+            class_name = info_list[-1]
+            model_path = ".".join(info_list[:-1])
+            model = import_module(model_path)
+            class_object = getattr(model, class_name)
+        else:
+            model_path = f"cobweb.db.{model_type}.{model_info.lower()}"
+            class_name = model_info.capitalize()
+            model = import_module(model_path)
+            class_object = getattr(model, class_name)
+        return class_object, class_name
+    elif issubclass(model_info, ABC):
+        inf_name = model_type.capitalize() + "Interface"
+        if issubclass_cobweb_interface(model_info, inf_name):
+            return model_info, model_info.__name__
+        raise ImportError()
+    raise TypeError()
 
 

{cobweb_launcher-0.1.2.dist-info → cobweb_launcher-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cobweb-launcher
-Version: 0.1.2
+Version: 0.1.3
 Summary: spider_hole
 Home-page: https://github.com/Juannie-PP/cobweb
 Author: Juannie-PP

{cobweb_launcher-0.1.2.dist-info → cobweb_launcher-0.1.3.dist-info}/RECORD

@@ -5,10 +5,10 @@ cobweb/interface.py,sha256=um_k2AAQl1HTOvfUlq914DjkpfZVwt2m1B65EpPKrmE,802
 cobweb/log.py,sha256=Gb3_y4IzTo5pJohTggBCU9rK6-ZN3hgTOHkoXHyN6CU,2384
 cobweb/setting.py,sha256=UAu_dLuIFYO98MxtlZ5sZqJcwKAUKq4Bu4KoKlV50Mc,288
 cobweb/task.py,sha256=77F5EaopSVlSX2TANv1lhuPHFI8ER8Jh4tSGrwDWAc0,1405
-cobweb/utils.py,sha256=3iQRn2s4fY-5ClrVo46RO9OhziRAyOn5hGJOQGjMMwQ,2176
+cobweb/utils.py,sha256=5ZcSfT3VCWF_Kl1APGYJYHtPhZPnr45nFqyyZA9LlOg,2663
 cobweb/db/__init__.py,sha256=4m9lqmxZCRbaih3Z3rl_BT0GugMd0dkOIgu_P9aeC84,63
 cobweb/db/oss_db.py,sha256=lFGNuH3tdIMsohVXQ_fTZPyBfS2oxYNmFNuQ-ZBQgm0,4221
-cobweb/db/redis_db.py,sha256=n2DlNiGNn8jQL09knR9tR0wA4YUijycfTRJkNaEEjGE,8182
+cobweb/db/redis_db.py,sha256=yoWy-GI0rjVmT-68Che-pypfqNwNti5JGkc9bYvJH2o,8202
 cobweb/db/scheduler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cobweb/db/scheduler/default.py,sha256=OxmFX7OvMEhKEq-NF7A8I9cA4V4qWw5vayS-yIbng0A,114
 cobweb/db/scheduler/textfile.py,sha256=atRDeNT-e5toNvyGsCXAxL1FJi77uSYktdCzH_hXGo8,821
@@ -18,13 +18,14 @@ cobweb/db/storer/loghub.py,sha256=4VqZacXWhidzINHXQu2_-E0HOBRCcc86f6LkKfnXD5I,17
 cobweb/db/storer/redis.py,sha256=7Q2XEQwBL6X_M1uvxzzuSBt6iw9piKw-_FWKm2INZDQ,412
 cobweb/db/storer/textfile.py,sha256=3mDHMvF6Sh5fn3IHzWQxyTUd45V-zUoH8vY3EoRlMx0,415
 cobweb/distributed/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cobweb/distributed/launcher.py,sha256=Yq1aAK-9c083U5O0ndtMhlE5VXtn6mLqeUtK4CE3Wfo,9181
-cobweb/distributed/models.py,sha256=5rRy16BHBq4EwWZxHcH_hJ6GJ0jEZ9hechSlZxzvdFQ,4513
+cobweb/distributed/launcher.py,sha256=jTtBXBmna_6yFdj6gyGQiiEtg8I0g5uI5h8kbHWt454,7998
+cobweb/distributed/models.py,sha256=Z46-Dwv--VLUr9t7wbNHaLIuEK0l-copJEbc-abfjb8,4617
 cobweb/single/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cobweb/single/models.py,sha256=lu8teNWnWcUwZFra8XmqyhzOAf3UyuEztwBr1Ne6pUs,2898
+cobweb/single/launcher.py,sha256=Z-PaX1f_nphdBwbIW1Ki6D_4xsrFmx94SO3BXaexYAg,7304
+cobweb/single/models.py,sha256=xIn0mefT_oMVynn3V6S4wkOCx6PGOemT4_fcuU7CSZs,4297
 cobweb/single/nest.py,sha256=mL8q9a5BjtoeUyzXCIVw_vyUsNY8ltbvQpYIIpZEDFU,5012
-cobweb_launcher-0.1.2.dist-info/LICENSE,sha256=z1rxSIGOyzcSb3orZxFPxzx-0C1vTocmswqBNxpKfEk,1063
-cobweb_launcher-0.1.2.dist-info/METADATA,sha256=tvBQE-ATQUl1dfbamK_VSbi09I9eCpqj5qOIc0ZDxYg,1225
-cobweb_launcher-0.1.2.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-cobweb_launcher-0.1.2.dist-info/top_level.txt,sha256=4GETBGNsKqiCUezmT-mJn7tjhcDlu7nLIV5gGgHBW4I,7
-cobweb_launcher-0.1.2.dist-info/RECORD,,
+cobweb_launcher-0.1.3.dist-info/LICENSE,sha256=z1rxSIGOyzcSb3orZxFPxzx-0C1vTocmswqBNxpKfEk,1063
+cobweb_launcher-0.1.3.dist-info/METADATA,sha256=vr4nnPQWibda20Nnn2KB2k7U81pWZLvVh8402NIhEgU,1225
+cobweb_launcher-0.1.3.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+cobweb_launcher-0.1.3.dist-info/top_level.txt,sha256=4GETBGNsKqiCUezmT-mJn7tjhcDlu7nLIV5gGgHBW4I,7
+cobweb_launcher-0.1.3.dist-info/RECORD,,